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

openhab/Links.py

@@ -0,0 +1,98 @@
+from .Client import OpenHABClient
+import json
+from urllib.parse import quote
+
+class Links:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Links class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllLinks(self, channelUID: str = None, itemName: str = None) -> list:
+        """
+        Gets all available links.
+
+        :param channelUID: Optional; Filters by the Channel UID.
+        :param itemName: Optional; Filters by the Item Name.
+
+        :return: A list of links containing details such as ItemName, ChannelUID, and configuration.
+        """
+        params = {}
+        if channelUID:
+            params["channelUID"] = channelUID
+        if itemName:
+            params["itemName"] = itemName
+        
+        return self.client.get("/links", params=params, header={"Content-Type": "application/json"})
+
+    def getIndividualLink(self, itemName: str, channelUID: str) -> dict:
+        """
+        Retrieves an individual link.
+
+        :param itemName: The name of the item.
+        :param channelUID: The UID of the channel.
+
+        :return: The link with details of the item, channel UID, and configuration.
+        """
+        itemName = quote(itemName, safe="")
+        channelUID = quote(channelUID, safe="")
+        
+        return self.client.get(f"/links/{itemName}/{channelUID}", header={"Accept": "application/json"})
+
+    def linkItemToChannel(self, itemName: str, channelUID: str, configuration: dict) -> dict:
+        """
+        Links an item to a channel.
+
+        :param itemName: The name of the item.
+        :param channelUID: The UID of the channel.
+        :param configuration: The configuration for the link.
+
+        :return: The API response when the link is successfully created.
+        """
+        itemName = quote(itemName, safe="")
+        channelUID = quote(channelUID, safe="")
+        
+        return self.client.put(f"/links/{itemName}/{channelUID}", data=json.dumps({"itemName": itemName, "channelUID": channelUID, "configuration": configuration}), header={"Content-Type": "application/json"})
+
+    def unlinkItemFromChannel(self, itemName: str, channelUID: str) -> dict:
+        """
+        Unlinks an item from a channel.
+
+        :param itemName: The name of the item.
+        :param channelUID: The UID of the channel.
+
+        :return: The API response when the link is successfully removed.
+        """
+        itemName = quote(itemName, safe="")
+        channelUID = quote(channelUID, safe="")
+        
+        return self.client.delete(f"/links/{itemName}/{channelUID}", header={"Content-Type": "application/json"})
+
+    def deleteAllLinks(self, object: str) -> dict:
+        """
+        Delete all links that refer to an item or thing.
+
+        :param object: The name of the item or the UID of the thing.
+
+        :return: The API response when all links are successfully deleted.
+        """
+        return self.client.delete(f"/links/{object}")
+
+    def getOrphanLinks(self) -> list:
+        """
+        Get orphan links between items and broken/non-existent thing channels.
+
+        :return: A list of orphan links.
+        """
+        return self.client.get("/links/orphans", header={"Accept": "application/json"})
+
+    def purgeUnusedLinks(self) -> dict:
+        """
+        Remove unused/orphaned links.
+
+        :return: The API response when the links are successfully removed.
+        """        
+        return self.client.post("/links/purge")

openhab/Logging.py

@@ -0,0 +1,55 @@
+from .Client import OpenHABClient
+import json
+
+class Logging:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Logging class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllLoggers(self) -> dict:
+        """
+        Get all loggers.
+
+        :return: A list of loggers with names and levels.
+        """        
+        return self.client.get("/logging")
+
+    def getSingleLogger(self, loggerName: str) -> dict:
+        """
+        Get a single logger.
+
+        :param loggerName: The name of the logger.
+
+        :return: The logger with the specified name and level.
+        """        
+        return self.client.get(f"/logging/{loggerName}")
+
+    def modifyOrAddLogger(self, loggerName: str, level: str) -> dict:
+        """
+        Modify or add a logger.
+
+        :param loggerName: The name of the logger.
+        :param level: The level of the logger.
+
+        :return: The API response after modification or addition.
+        """
+        data = {
+            "loggerName": loggerName,
+            "level": level
+        }
+
+        return self.client.put(f"/logging/{loggerName}", data=json.dumps(data), header={"Content-Type": "application/json"})
+
+    def removeLogger(self, loggerName: str) -> dict:
+        """
+        Remove a single logger.
+
+        :param loggerName: The name of the logger.
+
+        :return: The API response after removing the logger.
+        """        
+        return self.client.delete(f"/logging/{loggerName}")

openhab/ModuleTypes.py

@@ -0,0 +1,47 @@
+from .Client import OpenHABClient
+
+class ModuleTypes:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ModuleTypes class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getModuleTypes(self, tags=None, typeFilter=None, language: str = None):
+        """
+        Get all available module types.
+
+        :param tags: Optional filter for tags.
+        :param typeFilter: Optional filter for the type (action, condition, trigger).
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A list of module types.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        params = {}
+        if tags:
+            params["tags"] = tags
+        if typeFilter:
+            params["type"] = typeFilter
+
+        return self.client.get("/module-types", params=params, header=header)
+
+    def getModuleType(self, moduleTypeUID, language: str = None):
+        """
+        Gets a module type corresponding to the given UID.
+
+        :param moduleTypeUID: The UID of the module type.
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A dictionary with the module type information.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/module-types/{moduleTypeUID}", header=header)

openhab/Persistence.py

@@ -0,0 +1,103 @@
+from .Client import OpenHABClient
+import json
+
+class Persistence:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Persistence class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllServices(self) -> dict:
+        """
+        Gets a list of persistence services.
+
+        :return: A list of persistence services with IDs, labels, and types.
+        """        
+        return self.client.get("/persistence")
+
+    def getServiceConfiguration(self, serviceId: str) -> dict:
+        """
+        Gets a persistence service configuration.
+
+        :param serviceId: The ID of the persistence service.
+
+        :return: The configuration of the service.
+        """        
+        return self.client.get(f"/persistence/{serviceId}")
+
+    def setServiceConfiguration(self, serviceId: str, config: dict) -> dict:
+        """
+        Sets a persistence service configuration.
+
+        :param serviceId: The ID of the persistence service.
+        :param config: The configuration data.
+
+        :return: The response from the API after modification.
+        """        
+        return self.client.put(f"/persistence/{serviceId}", data=json.dumps({'serviceId': serviceId}), header={"Content-Type": "application/json", "Accept": "application/json"})
+
+    def deleteServiceConfiguration(self, serviceId: str) -> dict:
+        """
+        Deletes a persistence service configuration.
+
+        :param serviceId: The ID of the persistence service.
+
+        :return: The response from the API after deleting the configuration.
+        """
+        return self.client.delete(f"/persistence/{serviceId}")
+
+    def getItemsForService(self, serviceId: str) -> dict:
+        """
+        Gets a list of items available via a specific persistence service.
+
+        :param serviceId: The ID of the persistence service.
+
+        :return: A list of items with their last and earliest timestamps.
+        """
+        
+        return self.client.get(f"/persistence/items?serviceId={serviceId}")
+
+    def getItemPersistenceData(self, serviceId: str, itemName: str, startTime: str = None, endTime: str = None, page: int = 1, pageLength: int = 50) -> dict:
+        """
+        Gets item persistence data from the persistence service.
+
+        :param serviceId: The ID of the persistence service.
+        :param itemName: The name of the item.
+        :param startTime: The start time for the data. Defaults to 1 day before `endTime`.
+        :param endTime: The end time for the data. Defaults to the current time.
+        :param page: The page of data. Defaults to `1`.
+        :param pageLength: The number of data points per page. Defaults to `50`.
+
+        :return: The retrieved data points of the item.
+        """
+        return self.client.get(f"/persistence/items/{itemName}", params={"serviceId": serviceId, "starttime": startTime, "endtime": endTime, "page": page, "pagelength": pageLength})
+
+    def storeItemData(self, serviceId: str, itemName: str, time: str, state: str) -> dict:
+        """
+        Stores item persistence data into the persistence service.
+
+        :param serviceId: The ID of the persistence service.
+        :param itemName: The name of the item.
+        :param time: The time of the storage.
+        :param state: The state of the item to be stored.
+
+        :return: The response from the API after storing the data.
+        """
+        return self.client.put(f"/persistence/items/{itemName}", params={"serviceId": serviceId, "time": time, "state": state})
+
+    def deleteItemData(self, serviceId: str, itemName: str, startTime: str, endTime: str) -> dict:
+        """
+        Deletes item persistence data from a specific persistence service in a given time range.
+
+        :param serviceId: The ID of the persistence service.
+        :param itemName: The name of the item.
+        :param startTime: The start time of the data to be deleted.
+        :param endTime: The end time of the data to be deleted.
+
+        :return: The response from the API after deleting the data.
+        """
+
+        return self.client.delete(f"/persistence/items/{itemName}", params={"serviceId": serviceId, "starttime": startTime, "endtime": endTime})

openhab/ProfileTypes.py

@@ -0,0 +1,32 @@
+from .Client import OpenHABClient
+
+class ProfileTypes:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the ProfileTypes class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getProfileTypes(self, channelTypeUID=None, itemType=None, language: str = None):
+        """
+        Gets all available profile types.
+
+        :param channelTypeUID: Optional filter for the channel type.
+        :param itemType: Optional filter for the item type.
+        :param language: (Optional) Language setting for the Accept-Language header.
+        
+        :return: A list of profile types.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        params = {}
+        if channelTypeUID:
+            params["channelTypeUID"] = channelTypeUID
+        if itemType:
+            params["itemType"] = itemType
+
+        return self.client.get("/profile-types", params=params, header=header)

openhab/Rules.py

@@ -0,0 +1,206 @@
+from .Client import OpenHABClient
+import json
+
+class Rules:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Rules class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getRules(self, prefix=None, tags=None, summary=False, staticDataOnly=False):
+        """
+        Get available rules, optionally filtered by tags and/or prefix.
+
+        :param prefix: Optional prefix to filter the results.
+        :param tags: Optional tag array to filter the results.
+        :param summary: If true, only summary fields will be returned.
+        :param staticDataOnly: If true, only static data will be returned.
+
+        :return: A list of rules (JSON objects).
+        """
+        return self.client.get("/rules", params={"prefix": prefix, "tags": tags, "summary": summary, "staticDataOnly": staticDataOnly})
+
+    def createRule(self, ruleData: dict):
+        """
+        Creates a rule.
+
+        :param ruleData: The rule data to be created (as a dictionary).
+
+        :return: The created rule (JSON).
+        """
+        return self.client.post("/rules", data=json.dumps(ruleData), header={"Content-Type": "application/json"})
+
+    def getRule(self, ruleUID: str):
+        """
+        Gets the rule corresponding to the given UID.
+
+        :param ruleUID: The UID of the rule to retrieve.
+
+        :return: The rule object (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}")
+
+    def updateRule(self, ruleUID: str, ruleData: dict):
+        """
+        Updates an existing rule corresponding to the given UID.
+
+        :param ruleUID: The UID of the rule to update.
+        :param ruleData: The new rule data (as a dictionary).
+
+        :return: The updated rule (JSON).
+        """
+        return self.client.put(f"/rules/{ruleUID}", data=json.dumps(ruleData), header={"Content-Type": "application/json"})
+
+    def deleteRule(self, ruleUID: str):
+        """
+        Removes an existing rule corresponding to the given UID.
+
+        :param ruleUID: The UID of the rule to delete.
+
+        :return: The API response (status code).
+        """
+        return self.client.delete(f"/rules/{ruleUID}", header={"Accept": "application/json"})
+
+    def getModule(self, ruleUID: str, moduleCategory: str, moduleId: str):
+        """
+        Gets the rule's module corresponding to the given category and ID.
+
+        :param ruleUID: The UID of the rule.
+        :param moduleCategory: The category of the module.
+        :param moduleId: The ID of the module.
+
+        :return: The module (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/{moduleCategory}/{moduleId}", header={"Accept": "application/json"})
+
+    def getModuleConfig(self, ruleUID: str, moduleCategory: str, moduleId: str):
+        """
+        Gets the module's configuration.
+
+        :param ruleUID: The UID of the rule.
+        :param moduleCategory: The category of the module.
+        :param moduleId: The ID of the module.
+
+        :return: The module configuration (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/{moduleCategory}/{moduleId}/config")
+
+    def getModuleConfigParam(self, ruleUID: str, moduleCategory: str, moduleId: str, param: str):
+        """
+        Gets the module's configuration parameter.
+
+        :param ruleUID: The UID of the rule.
+        :param moduleCategory: The category of the module.
+        :param moduleId: The ID of the module.
+        :param param: The name of the configuration parameter.
+
+        :return: The configuration parameter value (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/{moduleCategory}/{moduleId}/config/{param}", header={'Accept': 'text/plain'})
+
+    def setModuleConfigParam(self, ruleUID: str, moduleCategory: str, moduleId: str, param: str, value: str):
+        """
+        Sets the module's configuration parameter value.
+
+        :param ruleUID: The UID of the rule.
+        :param moduleCategory: The category of the module.
+        :param moduleId: The ID of the module.
+        :param param: The name of the configuration parameter.
+        :param value: The value to set for the configuration parameter.
+
+        :return: The API response (status code).
+        """
+        return self.client.put(f"/rules/{ruleUID}/{moduleCategory}/{moduleId}/config/{param}", data=json.dumps(value), header={'Content-Type': 'text/plain'})
+
+    def getActions(self, ruleUID: str):
+        """
+        Gets the rule actions.
+        
+        :param ruleUID: The UID of the rule.
+
+        :return: A list of actions (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/actions")
+
+    def getConditions(self, ruleUID: str):
+        """
+        Gets the rule conditions.
+
+        :param ruleUID: The UID of the rule.
+
+        :return: A list of conditions (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/conditions")
+
+    def getConfiguration(self, ruleUID: str):
+        """
+        Gets the rule configuration values.
+        
+        :param ruleUID: The UID of the rule.
+
+        :return: The configuration of the rule (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/config")
+
+    def updateConfiguration(self, ruleUID: str, configData: dict):
+        """
+        Sets the rule configuration values.
+        
+        :param ruleUID: The UID of the rule.
+        :param configData: The new configuration data (as a dictionary).
+
+        :return: The updated configuration (JSON).
+        """
+        return self.client.put(f"/rules/{ruleUID}/config", data=json.dumps(configData), header={"Content-Type": "application/json"})
+
+    def setRuleState(self, ruleUID: str, enable: bool):
+        """
+        Sets the rule configuration values. Activates or deactivates the rule.
+
+        :param ruleUID: The UID of the rule.
+        :param enable: If true, the rule will be activated. If false, the rule will be deactivated.
+
+        :return: The API response (status code).
+        """
+        return self.client.post(f"/rules/{ruleUID}/enable", data="true" if enable else "false", header={"Content-type": "text/plain; charset=utf-8", "Accept": "text/plain"})
+
+    def enableRule(self, ruleUID: str):
+        return self.setRuleState(ruleUID, True)
+
+    def disableRule(self, ruleUID: str):
+        return self.setRuleState(ruleUID, False)
+
+    def runNow(self, ruleUID: str, contextData: dict = None):
+        """
+        Executes the rule's actions immediately.
+
+        :param ruleUID: The UID of the rule.
+        :param contextData: Optional context data for executing the rule.
+
+        :return: The API response (status code).
+        """
+        return self.client.post(f"/rules/{ruleUID}/runnow", data=json.dumps(contextData) or {})
+
+    def getTriggers(self, ruleUID: str):
+        """
+        Gets the rule triggers.
+
+        :param ruleUID: The UID of the rule.
+
+        :return: A list of triggers (JSON).
+        """
+        return self.client.get(f"/rules/{ruleUID}/triggers")
+
+    def simulateSchedule(self, fromTime: str, untilTime: str):
+        """
+        Simulates the executions of rules filtered by tag 'Schedule' within the given times.
+
+        :param fromTime: Simulates the executions of rules filtered by tag 'Schedule' within the given times.
+        :param untilTime: Simulates the executions of rules filtered by tag 'Schedule' within the given times.
+
+        :return: The simulation results (JSON).
+        """
+        return self.client.get("/rules/schedule/simulations", params={"from": fromTime, "until": untilTime}, header={'Accept': 'application/json'})

openhab/Services.py

@@ -0,0 +1,78 @@
+from .Client import OpenHABClient
+import json
+
+class Services:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Services class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getServices(self, language=None):
+        """
+        Get all configurable services.
+
+        :param language: Optional language setting (as header).
+
+        :return: A list of services (JSON).
+        """
+        return self.client.get("/services", header={"Accept-Language": language} if language else {})
+
+    def getService(self, serviceID: str, language=None):
+        """
+        Get configurable service for the given service ID.
+
+        :param serviceID: The ID of the service to retrieve.
+        :param language: Optional language setting (as header).
+
+        :return: The service object (JSON).
+        """
+        return self.client.get(f"/services/{serviceID}", header={"Accept-Language": language} if language else {})
+
+    def getServiceConfig(self, serviceID: str):
+        """
+        Get service configuration for the given service ID.
+
+        :param serviceID: The ID of the service.
+
+        :return: The configuration of the service (JSON).
+        """
+        return self.client.get(f"/services/{serviceID}/config")
+
+    def updateServiceConfig(self, serviceID: str, configData: dict):
+        """
+        Updates a service configuration for the given service ID and returns the old configuration.
+
+        :param serviceID: The ID of the service.
+        :param configData: The new configuration data (as a dictionary).
+
+        :return: The old configuration of the service (JSON).
+        """
+        return self.client.put(f"/services/{serviceID}/config", data=json.dumps(configData), header={"Content-type": "application/json", "Accept": "application/json"})
+
+    def deleteServiceConfig(self, serviceID: str):
+        """
+        Deletes a service configuration for the given service ID and returns the old configuration.
+
+        :param serviceID: The ID of the service.
+
+        :return: The old configuration of the service (JSON).
+        """
+        return self.client.delete(f"/services/{serviceID}/config", header={"Accept": "application/json"})
+
+    def getServiceContexts(self, serviceID: str, language=None):
+        """
+        Get existing multiple context service configurations for the given factory PID.
+
+        :param serviceID: The ID of the service.
+        :param language: Optional language setting (as header).
+
+        :return: A list of contexts (JSON).
+        """
+        header = {"Accept": "application/json"}  # Default to application/json
+        if language:
+            header["Accept-Language"] = language
+
+        return self.client.get(f"/services/{serviceID}/contexts", header=header)