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

openhab/Discovery.py

@@ -0,0 +1,28 @@
+from .Client import OpenHABClient
+
+class Discovery:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Discovery class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllDiscoveryBindings(self) -> list:
+        """
+        Gets all bindings that support discovery.
+
+        :return: Eine Liste der Bindings als Strings.
+        """
+        return self.client.get("/discovery")
+
+    def startBindingScan(self, bindingID: str) -> int:
+        """
+        Starts asynchronous discovery process for a binding and returns the timeout in seconds of the discovery operation.
+
+        :param bindingID: The ID of the binding for which the discovery is to be started.
+
+        :return: Timeout duration of the discovery operation in seconds.
+        """        
+        return self.client.post(f"/discovery/bindings/{bindingID}/scan")

openhab/Events.py

@@ -0,0 +1,302 @@
+from .Client import OpenHABClient
+import json
+
+class Events:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Events class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllEvents(self, topics: str = None) -> list:
+        """
+        Get all available events, optionally filtered by topic.
+
+        :param topics: A comma-separated list of topics to filter the events by.
+
+        :return: A SSE stream of events.
+        """
+        return self.client._OpenHABClient__executeSSE(
+            self.client.url + f"/rest/events" + (f"?topics={topics}" if topics else "")
+        )
+
+    def initiateStateTracker(self) -> str:
+        """
+        Initiates a new item state tracker connection.
+
+        :return: The connection ID as a string.
+        """
+
+        return self.client._OpenHABClient__executeSSE(self.client.url + "/rest/events/states", header={"Accept": "*/*"} )
+
+    def updateSseConnectionItems(self, connectionId: str, items: list) -> str:
+        """
+        Changes the list of items a SSE connection will receive state updates for.
+
+        :param connectionId: The ID of the existing connection.
+        :param items: A SSE stream of item names to subscribe to for state updates.
+
+        :return: A success message when the update is completed.
+        """
+                
+        return self.client.post(f"/rest/events/states/{connectionId}", data=json.dumps(items), header={"Content-Type": "application/json"})
+
+class ItemEvents:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ItemEvents class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def ItemEvent(self):
+        """
+        Get all item-related events.
+
+        :return: A SSE stream of item events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items")
+
+    def ItemAddedEvent(self, itemName: str = "*"):
+        """
+        Get events for added items.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of added item events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/added")
+
+    def ItemRemovedEvent(self, itemName: str = "*"):
+        """
+        Get events for removed items.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of removed item events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/removed")
+
+    def ItemUpdatedEvent(self, itemName: str = "*"):
+        """
+        Get events for updated items.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of updated item events.
+        """
+
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/updated")
+
+    def ItemCommandEvent(self, itemName: str = "*"):
+        """
+        Get events for item commands.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of item command events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/command")
+
+    def ItemStateEvent(self, itemName: str = "*"):
+        """
+        Get events for item state changes.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of item state events.
+        """
+
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/state")
+
+    def ItemStatePredictedEvent(self, itemName: str = "*"):
+        """
+        Get events for predicted item state changes.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of item state predicted events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/statepredicted")
+
+    def ItemStateChangedEvent(self, itemName: str = "*"):
+        """
+        Get events for item state changes.
+
+        :param itemName: The name of the item (default is "*").
+
+        :return: A SSE stream of item state changed events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/statechanged")
+
+    def GroupItemStateChangedEvent(self, itemName: str, memberName: str):
+        """
+        Get events for state changes of group items.
+
+        :param itemName: The name of the item.
+        :param memberName: The name of the group member.
+
+        :return: A SSE stream of group item state changed events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/items/{itemName}/{memberName}/statechanged")
+
+class ThingEvents:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ThingEvents class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def ThingAddedEvent(self, thingUID: str = "*"):
+        """
+        Get events for added things.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of added thing events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/things/{thingUID}/added")
+
+    def ThingRemovedEvent(self, thingUID: str = "*"):
+        """
+        Get events for removed things.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of removed thing events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/things/{thingUID}/removed")
+
+    def ThingUpdatedEvent(self, thingUID: str = "*"):
+        """
+        Get events for updated things.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of updated thing events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/things/{thingUID}/updated")
+
+    def ThingStatusInfoEvent(self, thingUID: str = "*"):
+        """
+        Get events for thing status information.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of thing status information events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/things/{thingUID}/status")
+
+    def ThingStatusInfoChangedEvent(self, thingUID: str = "*"):
+        """
+        Get events for thing status information changes.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of thing status information changed events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/things/{thingUID}/statuschanged")
+
+class InboxEvents:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the InboxEvents class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def InboxAddedEvent(self, thingUID: str = "*"):
+        """
+        Get events for added things in the inbox.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of added inbox events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/inbox/{thingUID}/added")
+
+    def InboxRemovedEvent(self, thingUID: str = "*"):
+        """
+        Get events for removed things in the inbox.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of removed inbox events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/inbox/{thingUID}/removed")
+
+    def InboxUpdatedEvent(self, thingUID: str = "*"):
+        """
+        Get events for updated things in the inbox.
+
+        :param thingUID: The UID of the thing (default is "*").
+
+        :return: A SSE stream of updated inbox events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/inbox/{thingUID}/updated")
+
+class LinkEvents:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the LinkEvents class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def ItemChannelLinkAddedEvent(self, itemName: str = "*", channelUID: str = "*"):
+        """
+        Get events for added item-channel links.
+
+        :param itemName: The name of the item (default is "*").
+        :param channelUID: The UID of the channel (default is "*").
+
+        :return: A SSE stream of added item-channel link events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/links/{itemName}-{channelUID}/added")
+
+    def ItemChannelLinkRemovedEvent(self, itemName: str = "*", channelUID: str = "*"):
+        """
+        Get events for removed item-channel links.
+
+        :param itemName: The name of the item (default is "*").
+        :param channelUID: The UID of the channel (default is "*").
+
+        :return: A SSE stream of removed item-channel link events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/links/{itemName}-{channelUID}/removed")
+
+class ChannelEvents:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ChannelEvents class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def ChannelDescriptionChangedEvent(self, channelUID: str = "*"):
+        """
+        Get events for changes in channel descriptions.
+
+        :param channelUID: The UID of the channel (default is "*").
+
+        :return: A SSE stream of channel description changed events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/channels/{channelUID}/descriptionchanged")
+
+    def ChannelTriggeredEvent(self, channelUID: str = "*"):
+        """
+        Get events for triggered channels.
+
+        :param channelUID: The UID of the channel (default is "*").
+
+        :return: A SSE stream of channel triggered events.
+        """
+        return self.client._OpenHABClient__executeSSE(self.client.url + f"/rest/events?topics=openhab/channels/{channelUID}/triggered")

openhab/Iconsets.py

@@ -0,0 +1,21 @@
+from .Client import OpenHABClient
+
+class Iconsets:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Iconsets class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllIconsets(self, language: str = None) -> list:
+        """
+        Gets all icon sets.
+
+        :param language: Optional language preference for the response (e.g. 'en', 'de').
+        
+        :return: A list of icon sets with details such as ID, label, description and supported formats.
+        """
+        
+        return self.client.get("/iconsets", header={"Accept-Language": language} if language else {})

openhab/Inbox.py

@@ -0,0 +1,64 @@
+from .Client import OpenHABClient
+import json
+
+class Inbox:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Inbox class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllDiscoveredThings(self, includeIgnored: bool = True) -> list:
+        """
+        Get all discovered things.
+
+        :param includeIgnored: Whether ignored entries should also be included (default: True).
+        
+        :return: A list of discovered things with details such as UID, flag, label, and properties.
+        """        
+        return self.client.get("/inbox", params={"includeIgnored": str(includeIgnored).lower()})
+
+    def removeDiscoveryResult(self, thingUID: str) -> dict:
+        """
+        Removes the discovery result from the inbox.
+
+        :param thingUID: The UID of the discovered thing to be removed.
+
+        :return: The API response to the delete request.
+        """        
+        return self.client.delete(f"/inbox/{thingUID}")
+
+    def approveDiscoveryResult(self, thingUID: str, thingLabel: str, newThingID: str = None, language: str = None) -> dict:
+        """
+        Approves the discovery result by adding the thing to the registry.
+        
+        :param thingUID: The UID of the discovered thing.
+        :param thingLabel: The new name of the thing.
+        :param newThingID: Optional: The new thing ID.
+        :param language: Optional: Language preference for the response.
+
+        :return: The API response to the approval request.
+        """
+        return self.client.post(f"/inbox/{thingUID}/approve", header={"Accept-Language": language, "Content-Type": "text/plain"} if language else {"Content-Type": "text/plain"}, params={"newThingID": newThingID} if newThingID else {}, data=thingLabel)
+
+    def ignoreDiscoveryResult(self, thingUID: str) -> dict:
+        """
+        Flags a discovery result as ignored for further processing.
+
+        :param thingUID: The UID of the discovered thing.
+
+        :return: The API response to the ignore request.
+        """
+        return self.client.post(f"/inbox/{thingUID}/ignore")
+
+    def unignoreDiscoveryResult(self, thingUID: str) -> dict:
+        """
+        Removes the ignore flag from a discovery result.
+
+        :param thingUID: The UID of the discovered thing.
+
+        :return: The API response to the unignore request.
+        """
+        return self.client.post(f"/inbox/{thingUID}/unignore")

openhab/Items.py

@@ -0,0 +1,264 @@
+from .Client import OpenHABClient
+import json
+
+class Items:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Items class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllItems(
+        self,
+        language: str = None,
+        type: str = None,
+        tags: str = None,
+        metadata: str = ".*",
+        recursive: bool = False,
+        fields: str = None,
+        staticDataOnly: bool = False,
+    ):
+        """
+        Get all available items.
+
+        :param language: Optional; Language filter for header "Accept-Language".
+        :param type: Optional; Item type filter.
+        :param tags: Optional; Item tag filter.
+        :param metadata: Optional; Metadata selector (default: .*).
+        :param recursive: Optional; Whether to fetch group members recursively (default: False).
+        :param fields: Optional; Limit to specific fields (comma-separated).
+        :param staticDataOnly: Optional; Only returns cached data (default: False).
+
+        :return: A dictionary or list containing the item data as returned by the API.
+        """
+        header = {}
+        if language:
+            header["Accept-Language"] = language
+
+        params = {
+            "type": type,
+            "tags": tags,
+            "metadata": metadata,
+            "recursive": str(recursive).lower(),
+            "fields": fields,
+            "staticDataOnly": str(staticDataOnly).lower(),
+        }
+
+        # Remove None values from parameters
+        params = {key: value for key, value in params.items() if value is not None}
+
+        return self.client.get("/items", header=header, params=params)
+
+    def addOrUpdateItems(self, items: list):
+        """
+        Adds a list of items to the registry or updates the existing items.
+
+        :param items: A list of item data (Dictionary).
+
+        :return: A response object or confirmation that the items were successfully added or updated.
+        """
+        return self.client.put("/items", data=json.dumps(items), header={"Content-Type": "application/json"})
+
+    def getItem(self, itemName: str, language: str = None, metadata: str = ".*", recursive: bool = True):
+        """
+        Gets a single item.
+
+        :param itemName: The name of the item.
+        :param language: Optional; Language filter for header "Accept-Language".
+        :param metadata: Optional; Metadata selector (default: .*).
+        :param recursive: Optional; Whether to fetch group members recursively (default: True).
+
+        :return: A dictionary containing the requested item data.
+        """
+        header = {}
+        if language:
+            header["Accept-Language"] = language
+
+        params = {
+            "metadata": metadata,
+            "recursive": str(recursive).lower(),
+        }
+
+        return self.client.get(f"/items/{itemName}", header=header, params=params)
+
+    def addOrUpdateItem(self, itemName: str, itemData: dict, language: str = None):
+        """
+        Adds a new item to the registry or updates the existing item.
+
+        :param itemName: The name of the item.
+        :param itemData: The data of the item (Dictionary).
+        :param language: Optional; Language filter for header "Accept-Language".
+
+        :return: A response object or confirmation that the item was successfully added or updated.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+        
+        return self.client.put(f"/items/{itemName}", header=header, data=json.dumps(itemData))
+
+    def sendCommand(self, itemName: str, command: str):
+        """
+        Sends a command to an item.
+
+        :param itemName: The name of the item.
+        :param command: The command to be sent (e.g., ON, OFF).
+
+        :return: A response object or confirmation that the command was successfully sent.
+        """
+        return self.client.post(f"/items/{itemName}", header={"Content-type": "text/plain; charset=utf-8", "Accept": "text/plain"}, data=command)
+
+    def postUpdate(self, itemName: str, state: str):
+        """
+        Updates the state of an item.
+
+        :param itemName: The name of the item.
+        :param state: The state to be signaled for the item.
+
+        :return: A response object or confirmation that the state was successfully updated.
+        """
+        return self.updateItemState(itemName, state)
+
+    def deleteItem(self, itemName: str):
+        """
+        Removes an item from the registry.
+
+        :param itemName: The name of the item.
+
+        :return: A response object or confirmation that the item was successfully deleted.
+        """
+        return self.client.delete(f"/items/{itemName}")
+
+    def addGroupMember(self, itemName: str, memberItemName: str):
+        """
+        Adds a new member to a group item.
+
+        :param itemName: The name of the group item.
+        :param memberItemName: The name of the member item.
+
+        :return: A response object or confirmation that the group member was successfully added.
+        """
+        return self.client.put(f"/items/{itemName}/members/{memberItemName}")
+
+    def removeGroupMember(self, itemName: str, memberItemName: str):
+        """
+        Removes an existing member from a group item.
+
+        :param itemName: The name of the group item.
+        :param memberItemName: The name of the member item.
+
+        :return: A response object or confirmation that the group member was successfully removed.
+        """
+        return self.client.delete(f"/items/{itemName}/members/{memberItemName}")
+
+    def addMetadata(self, itemName: str, namespace: str, metadata: dict):
+        """
+        Adds metadata to an item.
+
+        :param itemName: The name of the item.
+        :param namespace: The namespace of the metadata.
+        :param metadata: A dictionary containing the metadata.
+
+        :return: A response object or confirmation that the metadata was successfully added.
+        """
+        return self.client.put(f"/items/{itemName}/metadata/{namespace}", header={"Content-Type": "application/json"}, data=json.dumps(metadata))
+
+    def removeMetadata(self, itemName: str, namespace: str):
+        """
+        Removes metadata from an item.
+
+        :param itemName: The name of the item.
+        :param namespace: The namespace of the metadata.
+
+        :return: A response object or confirmation that the metadata was successfully removed.
+        """
+        return self.client.delete(f"/items/{itemName}/metadata/{namespace}")
+
+    def getMetadataNamespaces(self, itemName: str, language: str = None):
+        """
+        Gets the namespaces of an item.
+
+        :param itemName: The name of the item.
+        :param language: Optional; Language filter for header "Accept-Language".
+
+        :return: A list of namespaces associated with the item.
+        """
+        header = {}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/items/{itemName}/metadata/namespaces", header=header)
+
+    def getSemanticItem(self, itemName: str, semanticClass: str, language: str = None):
+        """
+        Gets the item that defines the requested semantics of an item.
+
+        :param itemName: The name of the item.
+        :param semanticClass: The requested semantic class.
+        :param language: Optional; Language filter for header "Accept-Language".
+
+        :return: A dictionary containing the semantic item data.
+        """
+        header = {}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/items/{itemName}/semantic/{semanticClass}", header=header)
+
+    def getItemState(self, itemName: str):
+        """
+        Gets the state of an item.
+
+        :param itemName: The name of the item.
+
+        :return: A dictionary containing the current state of the item.
+        """
+        return self.client.get(f"/items/{itemName}/state")
+
+    def updateItemState(self, itemName: str, state: str, language: str = None):
+        """
+        Updates the state of an item.
+
+        :param itemName: The name of the item.
+        :param state: The new state of the item.
+        :param language: Optional; Language filter for header "Accept-Language".
+
+        :return: A response object or confirmation that the state was successfully updated.
+        """
+        header = {"Content-type": "text/plain; charset=utf-8", "Accept": "text/plain"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.put(f"/items/{itemName}/state", header=header, data=state)
+            
+    def addTag(self, itemName: str, tag: str):
+        """
+        Adds a tag to an item.
+
+        :param itemName: The name of the item.
+        :param tag: The tag to be added.
+
+        :return: A response object or confirmation that the tag was successfully added.
+        """
+        return self.client.put(f"/items/{itemName}/tags/{tag}")
+
+    def removeTag(self, itemName: str, tag: str):
+        """
+        Removes a tag from an item.
+
+        :param itemName: The name of the item.
+        :param tag: The tag to be removed.
+
+        :return: A response object or confirmation that the tag was successfully removed.
+        """
+        return self.client.delete(f"/items/{itemName}/tags/{tag}")
+
+    def purgeOrphanedMetadata(self):
+        """
+        Remove unused/orphaned metadata.
+
+        :return: A response object or confirmation that orphaned metadata was successfully purged.
+        """
+        return self.client.post("/items/metadata/purge")