python-openhab-rest-client 0.1.0__tar.gz → 0.1.1__tar.gz

{python_openhab_rest_client-0.1.0/python_openhab_rest_client.egg-info → python_openhab_rest_client-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-openhab-rest-client
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Python client for the openHAB REST API. This library enables easy interaction with the openHAB REST API to control smart home devices, retrieve status information, and process events.
 Home-page: https://github.com/Michdo93/python-openhab-rest-client
 Author: Michael Christian Dörflinger

python_openhab_rest_client-0.1.1/openhab/Actions.py

@@ -0,0 +1,100 @@
+from .Client import OpenHABClient
+import json
+import requests
+
+
+class Actions:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Actions class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient that is used for REST-API communication.
+        """
+        self.client = client
+
+    def getAllActions(self, thingUID: str, language: str = None) -> list:
+        """
+        Get all available actions for provided thing UID.
+
+        :param thingUID: The UID of the thing for which actions are to be retrieved.
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A list of actions.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get(f"/actions/{thingUID}", header=header)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 204:
+                return {"error": "No actions found."}
+            elif status_code == 404:
+                return {"error": f"Thing not found: {thingUID}"}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 204:
+            return {"error": "No actions found."}
+        elif status_code == 404:
+            return {"error": f"Thing not found: {thingUID}"}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def executeAction(self, thingUID: str, actionUID: str, actionInputs: dict, language: str = None) -> str:
+        """
+        Executes a thing action.
+
+        :param thingUID: The UID of the thing on which the action is to be executed.
+        :param actionUID: The UID of the action to be executed.
+        :param actionInputs: The inputs for the action as a dictionary.
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A response from the server.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.post(
+                f"/actions/{thingUID}/{actionUID}", header=header, data=json.dumps(actionInputs))
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Action not found."}
+            elif status_code == 500:
+                return {"error": "Creation of action handler or execution failed."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Action not found."}
+        elif status_code == 500:
+            return {"error": "Creation of action handler or execution failed."}
+
+        return {"error": f"Unexpected response: {status_code}"}

python_openhab_rest_client-0.1.1/openhab/Addons.py

@@ -0,0 +1,405 @@
+import json
+from .Client import OpenHABClient
+import urllib.parse
+import requests
+
+
+class Addons:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Addons class with an OpenHABClient instance.
+
+        :param client: An instance of OpenHABClient used for REST API communication.
+        """
+        self.client = client
+
+    def getAddons(self, serviceID: str = None, language: str = None) -> dict:
+        """
+        Retrieves a list of all available add-ons.
+
+        :param serviceID: Optional service ID to filter the results.
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing the add-ons data.
+        """
+        params = {"serviceId": serviceID} if serviceID else {}
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get("/addons", header=header, params=params)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Service not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Service not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getAddon(self, addonID: str, serviceID: str = None, language: str = None) -> dict:
+        """
+        Retrieves details of a specific add-on by its ID.
+
+        :param addonID: The unique identifier of the add-on.
+        :param serviceID: Optional service ID to filter the results.
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing details of the specified add-on.
+        """
+        params = {"serviceId": serviceID} if serviceID else {}
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get(
+                f"/addons/{addonID}", header=header, params=params)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getAddonConfig(self, addonID: str, serviceID: str = None) -> dict:
+        """
+        Retrieves the configuration of a specific add-on.
+
+        :param addonID: The unique identifier of the add-on.
+        :param serviceID: Optional service ID to filter the results.
+
+        :return: A dictionary containing the configuration of the specified add-on.
+        """
+        params = {"serviceId": serviceID} if serviceID else {}
+
+        try:
+            response = self.client.get(
+                f"/addons/{addonID}/config", header={"Content-Type": "application/json"}, params=params)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 500:
+                return {"error": "Configuration can not be read due to internal error."}
+            elif status_code == 404:
+                return {"error": "Add-on does not exist."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Add-on does not exist."}
+        elif status_code == 500:
+            return {"error": "Configuration can not be read due to internal error."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def updateAddonConfig(self, addonID: str, configData: dict, serviceID: str = None) -> dict:
+        """
+        Updates the configuration of a specific add-on and returns the updated configuration.
+
+        :param addonID: The unique identifier of the add-on.
+        :param configData: A dictionary containing the new configuration settings.
+        :param serviceID: Optional service ID to specify the target service.
+
+        :return: A dictionary containing the updated configuration.
+        """
+        data = {
+            **configData}  # Create a copy to avoid modifying the original dictionary
+        if serviceID:
+            data["serviceId"] = serviceID
+
+        try:
+            response = self.client.put(
+                f"/addons/{addonID}/config", header={"Content-Type": "application/json"}, data=json.dumps(data))
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 500:
+                return {"error": "Configuration can not be updated due to internal error."}
+            elif status_code == 404:
+                return {"error": "Add-on does not exist."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Add-on does not exist."}
+        elif status_code == 500:
+            return {"error": "Configuration can not be updated due to internal error."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def installAddon(self, addonID: str, serviceID: str = None, language: str = None) -> dict:
+        """
+        Installs an add-on by its ID.
+
+        :param addonID: The unique identifier of the add-on.
+        :param serviceID: Optional service ID to specify the target service.
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing the installation status.
+        """
+        data = {"serviceId": serviceID} if serviceID else {}
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.post(
+                f"/addons/{addonID}/install", header=header, data=data)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def uninstallAddon(self, addonID: str, serviceID: str = None, language: str = None) -> dict:
+        """
+        Uninstalls an add-on by its ID.
+
+        :param addonID: The unique identifier of the add-on.
+        :param serviceID: Optional service ID to specify the target service.
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing the uninstallation status.
+        """
+        data = {"serviceId": serviceID} if serviceID else {}
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.post(
+                f"/addons/{addonID}/uninstall", header=header, data=data)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getAddonServices(self, language: str = None) -> dict:
+        """
+        Retrieves a list of all available add-on services.
+
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing the available add-on services.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get(
+                "/addons/services", header=header, params=None)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code != 200:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getAddonSuggestions(self, language: str = None) -> dict:
+        """
+        Retrieves a list of suggested add-ons for installation.
+
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing suggested add-ons.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get(
+                "/addons/suggestions", header=header, params=None)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code != 200:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getAddonTypes(self, language: str = None) -> dict:
+        """
+        Retrieves a list of all available add-on types.
+
+        :param language: Optional language preference for the response.
+
+        :return: A dictionary containing available add-on types.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get(
+                "/addons/types", header=header, params=None)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Service not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Service not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def installAddonFromUrl(self, url: str) -> dict:
+        """
+        Installs an add-on from a given URL.
+
+        :param url: The URL of the add-on to install.
+
+        :return: A dictionary containing the installation status.
+        """
+        encoded_url = urllib.parse.quote(url, safe='')  # Encode the URL
+        endpoint = f"/addons/url/{encoded_url}/install"
+
+        try:
+            response = self.client.post(
+                endpoint, header={"Content-Type": "text/plain"}, data=None)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 400:
+                return {"error": "The given URL is malformed or not valid."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 400:
+            return {"error": "The given URL is malformed or not valid."}
+
+        return {"error": f"Unexpected response: {status_code}"}

python_openhab_rest_client-0.1.1/openhab/Audio.py

@@ -0,0 +1,152 @@
+from .Client import OpenHABClient
+import requests
+
+
+class Audio:
+    def __init__(self, client: OpenHABClient):
+        """
+        Initializes the Audio class with an OpenHABClient object.
+
+        :param client: An instance of OpenHABClient used for REST API communication.
+        """
+        self.client = client
+
+    def getDefaultSink(self, language: str = None):
+        """
+        Retrieves the default sink if defined, or the first available sink.
+
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A dictionary containing information about the default sink.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get("/audio/defaultsink", header=header)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Sink not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Sink not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getDefaultSource(self, language: str = None):
+        """
+        Retrieves the default source if defined, or the first available source.
+
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A dictionary containing information about the default source.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get("/audio/defaultsource", header=header)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code == 404:
+                return {"error": "Sink not found."}
+            else:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+        elif status_code == 404:
+            return {"error": "Service not found."}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getSinks(self, language: str = None):
+        """
+        Retrieves a list of all available sinks.
+
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A list of available sinks.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get("/audio/sinks", header=header)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code != 200:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+
+        return {"error": f"Unexpected response: {status_code}"}
+
+    def getSources(self, language: str = None):
+        """
+        Retrieves a list of all available sources.
+
+        :param language: (Optional) Language setting for the Accept-Language header.
+
+        :return: A list of available sources.
+        """
+        header = {"Content-Type": "application/json"}
+        if language:
+            header["Accept-Language"] = language
+
+        try:
+            response = self.client.get("/audio/sources", header=header)
+
+            if isinstance(response, dict) and "status" in response:
+                status_code = response["status"]
+            else:
+                return response
+
+        except requests.exceptions.HTTPError as err:
+            status_code = err.response.status_code
+            if status_code != 200:
+                return {"error": f"HTTP error {status_code}: {str(err)}"}
+
+        except requests.exceptions.RequestException as err:
+            return {"error": f"Request error: {str(err)}"}
+
+        if status_code == 200:
+            return {"message": "OK"}
+
+        return {"error": f"Unexpected response: {status_code}"}