ihcsdk 2.8.7__py3-none-any.whl → 2.8.11__py3-none-any.whl

ihcsdk/__init__.py

@@ -1 +1 @@
-"""Init file for ihcsdk """
+"""Init file for ihcsdk."""

ihcsdk/ihcclient.py

@@ -1,12 +1,13 @@
-"""
-Implements the connection to the ihc controller
-"""
+"""Implements the connection to the ihc controller."""
 
 # pylint: disable=bare-except
 import base64
 import datetime
 import io
+import xml.etree.ElementTree as ET
 import zlib
+from typing import Any, ClassVar, Literal
+
 from ihcsdk.ihcconnection import IHCConnection
 from ihcsdk.ihcsslconnection import IHCSSLConnection
 
@@ -14,17 +15,17 @@ IHCSTATE_READY = "text.ctrl.state.ready"
 
 
 class IHCSoapClient:
-    """Implements a limited set of the soap request for the IHC controller"""
+    """Implements a limited set of the soap request for the IHC controller."""
 
-    ihcns = {
+    ihcns: ClassVar[dict[str, str]] = {
         "SOAP-ENV": "http://schemas.xmlsoap.org/soap/envelope/",
         "ns1": "utcs",
         "ns2": "utcs.values",
         "ns3": "utcs.values",
     }
 
-    def __init__(self, url: str):
-        """Initialize the IIHCSoapClient with a url for the controller"""
+    def __init__(self, url: str) -> None:
+        """Initialize the IIHCSoapClient with a url for the controller."""
         self.url = url
         self.username = ""
         self.password = ""
@@ -33,10 +34,17 @@ class IHCSoapClient:
         else:
             self.connection = IHCConnection(url)
 
+    def close(self) -> None:
+        """Close the connection."""
+        self.connection.close()
+        self.connection = None
+
     def authenticate(self, username: str, password: str) -> bool:
-        """Do an Authentricate request and save the cookie returned to be used
-        on the following requests.
-        Return True if the request was successfull
+        """
+        Do an Authentricate request.
+
+        And save the cookie returned to be used on the following requests.
+        Return True if the request was successfull.
         """
         self.username = username
         self.password = password
@@ -61,7 +69,7 @@ class IHCSoapClient:
         return False
 
     def get_state(self) -> str:
-        """Get the controller state"""
+        """Get the controller state."""
         xdoc = self.connection.soap_action("/ws/ControllerService", "getState", "")
         if xdoc is not False:
             return xdoc.find(
@@ -69,18 +77,16 @@ class IHCSoapClient:
             ).text
         return False
 
-    def wait_for_state_change(self, state: str, waitsec) -> str:
-        """Wait for controller state change and return state"""
-        payload = """<ns1:waitForControllerStateChange1
+    def wait_for_state_change(self, state: str, waitsec: int) -> str:
+        """Wait for controller state change and return state."""
+        payload = f"""<ns1:waitForControllerStateChange1
                      xmlns:ns1=\"utcs\" xsi:type=\"ns1:WSControllerState\">
                      <ns1:state xsi:type=\"xsd:string\">{state}</ns1:state>
                      </ns1:waitForControllerStateChange1>
                      <ns2:waitForControllerStateChange2
                      xmlns:ns2=\"utcs\" xsi:type=\"xsd:int\">
-                     {wait}</ns2:waitForControllerStateChange2>
-                     """.format(
-            state=state, wait=waitsec
-        )
+                     {waitsec}</ns2:waitForControllerStateChange2>
+                     """
         xdoc = self.connection.soap_action(
             "/ws/ControllerService", "waitForControllerStateChange", payload
         )
@@ -92,9 +98,11 @@ class IHCSoapClient:
         return False
 
     def get_project(self) -> str:
-        """Get the ihc project in single SOAP action.
-        You should use the get_project_in_segments to get the project in multiple segments.
-        This will stress the IHC controller less
+        """
+        Get the ihc project in single SOAP action.
+
+        You should use the get_project_in_segments to get the project in multiple
+        segments. This will stress the IHC controller less.
         """
         xdoc = self.connection.soap_action("/ws/ControllerService", "getIHCProject", "")
         if xdoc is not False:
@@ -109,25 +117,31 @@ class IHCSoapClient:
             )
         return False
 
-    def get_project_in_segments(self, info=None) -> str:
-        """Get the ihc project per segments.
-        Param: info .. reuse existing project info. If not provided, the get_project_info() is called internally.
+    def get_project_in_segments(self, info: dict[str, Any] | None = None) -> str:
+        """
+        Get the ihc project per segments.
+
+        Param: info .. reuse existing project info.
+        If not provided, the get_project_info() is called internally.
         """
         if info is None:
             info = self.get_project_info()
         if info:
-            projectMajor = info.get("projectMajorRevision", 0)
-            projectMinor = info.get("projectMinorRevision", 0)
+            project_major = info.get("projectMajorRevision", 0)
+            project_minor = info.get("projectMinorRevision", 0)
             buffer = io.BytesIO()
             for s in range(self.get_project_number_of_segments()):
-                buffer.write(self.get_project_segment(s, projectMajor, projectMinor))
+                segment = self.get_project_segment(s, project_major, project_minor)
+                if segment is False:
+                    return False
+                buffer.write(segment)
             return zlib.decompress(buffer.getvalue(), 16 + zlib.MAX_WBITS).decode(
                 "ISO-8859-1"
             )
         return False
 
-    def get_project_info(self) -> dict:
-        """Returns dictionary of project info items."""
+    def get_project_info(self) -> dict[str, Any]:
+        """Return dictionary of project info items."""
         xdoc = self.connection.soap_action(
             "/ws/ControllerService", "getProjectInfo", ""
         )
@@ -142,7 +156,7 @@ class IHCSoapClient:
         return False
 
     def get_project_number_of_segments(self) -> int:
-        """Returns the number of segments needed to fetch the current ihc-project."""
+        """Return the number of segments needed to fetch the current ihc-project."""
         xdoc = self.connection.soap_action(
             "/ws/ControllerService", "getIHCProjectNumberOfSegments", ""
         )
@@ -155,20 +169,23 @@ class IHCSoapClient:
             )
         return False
 
-    def get_project_segment(self, segment: int, projectMajor: int, projectMinor: int):
-        """Returns a segment of the ihc-project with the given number.
-        Returns null if the segment number increases above the number of segments available.
-        The segments are offset from 0.
-        The project-versions given as parameters are used to indentify the project that should be fetched.
-        That is, to make sure that you suddenly don't get segments belonging to another project.
+    def get_project_segment(
+        self, segment: int, project_major: int, project_minor: int
+    ) -> bytes:
+        """
+        Return a segment of the ihc-project with the given number.
+
+        Returns null if the segment number increases above the number of segments
+        available. The segments are offset from 0.
+        The project-versions given as parameters are used to indentify the project that
+        should be fetched. That is, to make sure that you suddenly don't get segments
+        belonging to another project.
         """
-        payload = """
+        payload = f"""
             <getIHCProjectSegment1 xmlns="utcs">{segment}</getIHCProjectSegment1>
-            <getIHCProjectSegment2 xmlns="utcs">{major}</getIHCProjectSegment2>
-            <getIHCProjectSegment3 xmlns="utcs">{minor}</getIHCProjectSegment3>
-            """.format(
-            segment=segment, major=projectMajor, minor=projectMinor
-        )
+            <getIHCProjectSegment2 xmlns="utcs">{project_major}</getIHCProjectSegment2>
+            <getIHCProjectSegment3 xmlns="utcs">{project_minor}</getIHCProjectSegment3>
+            """
         xdoc = self.connection.soap_action(
             "/ws/ControllerService", "getIHCProjectSegment", payload
         )
@@ -179,29 +196,22 @@ class IHCSoapClient:
             ).text
             if not base64:
                 return False
-            compresseddata = base64.b64decode(base64data)
-            return compresseddata
+            return base64.b64decode(base64data)
         return False
 
     def set_runtime_value_bool(self, resourceid: int, value: bool) -> bool:
-        """Set a boolean runtime value"""
-        if value:
-            boolvalue = "true"
-        else:
-            boolvalue = "false"
-
-        payload = """
+        """Set a boolean runtime value."""
+        boolvalue = "true" if value else "false"
+        payload = f"""
             <setResourceValue1 xmlns=\"utcs\"
             xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
             <value i:type=\"a:WSBooleanValue\" xmlns:a=\"utcs.values\">
-            <a:value>{value}</a:value></value>
+            <a:value>{boolvalue}</a:value></value>
             <typeString/>
-            <resourceID>{id}</resourceID>
+            <resourceID>{resourceid}</resourceID>
             <isValueRuntime>true</isValueRuntime>
             </setResourceValue1>
-            """.format(
-            id=resourceid, value=boolvalue
-        )
+            """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "setResourceValue", payload
         )
@@ -212,20 +222,18 @@ class IHCSoapClient:
             return result == "true"
         return False
 
-    def set_runtime_value_int(self, resourceid: int, intvalue: int):
-        """Set a integer runtime value"""
-        payload = """
+    def set_runtime_value_int(self, resourceid: int, intvalue: int) -> bool:
+        """Set a integer runtime value."""
+        payload = f"""
             <setResourceValue1 xmlns=\"utcs\"
             xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
             <value i:type=\"a:WSIntegerValue\" xmlns:a=\"utcs.values\">
-            <a:integer>{value}</a:integer></value>
+            <a:integer>{intvalue}</a:integer></value>
             <typeString/>
-            <resourceID>{id}</resourceID>
+            <resourceID>{resourceid}</resourceID>
             <isValueRuntime>true</isValueRuntime>
             </setResourceValue1>
-            """.format(
-            id=resourceid, value=intvalue
-        )
+            """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "setResourceValue", payload
         )
@@ -236,21 +244,19 @@ class IHCSoapClient:
             return result == "true"
         return False
 
-    def set_runtime_value_float(self, resourceid: int, floatvalue: float):
-        """Set a flot runtime value"""
-        payload = """
+    def set_runtime_value_float(self, resourceid: int, floatvalue: float) -> bool:
+        """Set a flot runtime value."""
+        payload = f"""
             <setResourceValue1 xmlns=\"utcs\"
             xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
             <value i:type=\"a:WSFloatingPointValue\" xmlns:a=\"utcs.values\">
-            <a:floatingPointValue>{value}</a:floatingPointValue></value>
+            <a:floatingPointValue>{floatvalue}</a:floatingPointValue></value>
             <typeString/>
-            <resourceID>{id}</resourceID>
+            <resourceID>{resourceid}</resourceID>
             <isValueRuntime>true</isValueRuntime>
             </setResourceValue1>
             </s:Body>
-            """.format(
-            id=resourceid, value=floatvalue
-        )
+            """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "setResourceValue", payload
         )
@@ -261,21 +267,19 @@ class IHCSoapClient:
             return result == "true"
         return False
 
-    def set_runtime_value_timer(self, resourceid: int, timer: int):
-        """Set a timer runtime value in milliseconds"""
-        payload = """
+    def set_runtime_value_timer(self, resourceid: int, timer: int) -> bool:
+        """Set a timer runtime value in milliseconds."""
+        payload = f"""
             <setResourceValue1 xmlns=\"utcs\"
             xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
             <value i:type=\"a:WSTimerValue\" xmlns:a=\"utcs.values\">
-            <a:milliseconds>{value}</a:milliseconds></value>
+            <a:milliseconds>{timer}</a:milliseconds></value>
             <typeString/>
-            <resourceID>{id}</resourceID>
+            <resourceID>{resourceid}</resourceID>
             <isValueRuntime>true</isValueRuntime>
             </setResourceValue1>
             </s:Body>
-            """.format(
-            id=resourceid, value=timer
-        )
+            """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "setResourceValue", payload
         )
@@ -288,8 +292,8 @@ class IHCSoapClient:
 
     def set_runtime_value_time(
         self, resourceid: int, hours: int, minutes: int, seconds: int
-    ):
-        """Set a time runtime value in hours:minutes:seconds"""
+    ) -> bool:
+        """Set a time runtime value in hours:minutes:seconds."""
         payload = f"""
             <setResourceValue1 xmlns=\"utcs\"
             xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
@@ -314,15 +318,16 @@ class IHCSoapClient:
             return result == "true"
         return False
 
-    def get_time(resource_value):
-
+    @staticmethod
+    def _get_time(resource_value: ET.Element) -> datetime.time:
         hours = int(resource_value.find("./ns2:hours", IHCSoapClient.ihcns).text)
         minutes = int(resource_value.find("./ns2:minutes", IHCSoapClient.ihcns).text)
         seconds = int(resource_value.find("./ns2:seconds", IHCSoapClient.ihcns).text)
 
         return datetime.time(hours, minutes, seconds)
 
-    def get_datetime(resource_value):
+    @staticmethod
+    def _get_datetime(resource_value: ET.Element) -> datetime.datetime:
         year = int(resource_value.find("./ns1:year", IHCSoapClient.ihcns).text)
         month = int(
             resource_value.find("./ns1:monthWithJanuaryAsOne", IHCSoapClient.ihcns).text
@@ -331,55 +336,74 @@ class IHCSoapClient:
         hours = int(resource_value.find("./ns1:hours", IHCSoapClient.ihcns).text)
         minutes = int(resource_value.find("./ns1:minutes", IHCSoapClient.ihcns).text)
         seconds = int(resource_value.find("./ns1:seconds", IHCSoapClient.ihcns).text)
-        return datetime.datetime(year, month, day, hours, minutes, seconds)
+        return datetime.datetime(year, month, day, hours, minutes, seconds)  # noqa: DTZ001
 
-    def get_date(resource_value):
+    @staticmethod
+    def _get_date(resource_value: ET.Element) -> datetime.datetime:
         year = int(resource_value.find("./ns2:year", IHCSoapClient.ihcns).text)
         if year == 0:
-            year = datetime.datetime.today().year
+            year = datetime.datetime.today().year  # noqa: DTZ002
         month = int(resource_value.find("./ns2:month", IHCSoapClient.ihcns).text)
         day = int(resource_value.find("./ns2:day", IHCSoapClient.ihcns).text)
-        return datetime.datetime(year, month, day)
-
-    def __get_value(resource_value):
-        """Get a runtime value from the xml base on the type in the xml"""
-        if resource_value == None:
+        return datetime.datetime(year, month, day)  # noqa: DTZ001
+
+    @staticmethod
+    def __get_value(
+        resource_value: ET.Element,
+    ) -> bool | int | float | str | datetime.datetime | None:
+        """Get a runtime value from the xml base on the type in the xml."""
+        if resource_value is None:
             return None
         valuetype = resource_value.attrib[
             "{http://www.w3.org/2001/XMLSchema-instance}type"
         ].split(":")[1]
-        default_fn = lambda v: v.text
-        result = {
-            "WSBooleanValue": lambda v: (
-                v.find("./ns2:value", IHCSoapClient.ihcns).text == "true"
-            ),
-            "WSIntegerValue": lambda v: int(
-                v.find("./ns2:integer", IHCSoapClient.ihcns).text
-            ),
-            "WSFloatingPointValue": lambda v: round(
-                float(v.find("./ns2:floatingPointValue", IHCSoapClient.ihcns).text), 2
-            ),
-            "WSEnumValue": lambda v: v.find("./ns2:enumName", IHCSoapClient.ihcns).text,
-            "WSTimerValue": lambda v: int(
-                v.find("./ns2:milliseconds", IHCSoapClient.ihcns).text
-            ),
-            "WSTimeValue": lambda v: IHCSoapClient.get_time(v),
-            "WSDate": lambda v: IHCSoapClient.get_datetime(v),
-            "WSDateValue": lambda v: IHCSoapClient.get_date(v),
-            "int": lambda v: int(v.text),
-        }.get(valuetype, default_fn)(resource_value)
-
+        result = resource_value.text
+        match valuetype:
+            case "WSBooleanValue":
+                result = (
+                    resource_value.find("./ns2:value", IHCSoapClient.ihcns).text
+                    == "true"
+                )
+            case "WSIntegerValue":
+                result = int(
+                    resource_value.find("./ns2:integer", IHCSoapClient.ihcns).text
+                )
+            case "WSFloatingPointValue":
+                result = round(
+                    float(
+                        resource_value.find(
+                            "./ns2:floatingPointValue", IHCSoapClient.ihcns
+                        ).text
+                    ),
+                    2,
+                )
+            case "WSEnumValue":
+                result = resource_value.find("./ns2:enumName", IHCSoapClient.ihcns).text
+            case "WSTimerValue":
+                return int(
+                    resource_value.find("./ns2:milliseconds", IHCSoapClient.ihcns).text
+                )
+            case "WSTimeValue":
+                result = IHCSoapClient._get_time(resource_value)
+            case "WSDate":
+                result = IHCSoapClient._get_datetime(resource_value)
+            case "WSDateValue":
+                result = IHCSoapClient._get_date(resource_value)
+            case "int":
+                result = int(resource_value.text)
         return result
 
-    def get_runtime_value(self, resourceid: int):
-        """Get runtime value of specified resource it
+    def get_runtime_value(
+        self, resourceid: int
+    ) -> bool | int | float | str | datetime.datetime | None:
+        """
+        Get runtime value of specified resource id.
+
         The returned value will be boolean, integer or float
         Return None if resource cannot be found or on error
         """
-        payload = """<getRuntimeValue1 xmlns="utcs">{id}</getRuntimeValue1>
-                  """.format(
-            id=resourceid
-        )
+        payload = f"""<getRuntimeValue1 xmlns="utcs">{resourceid}</getRuntimeValue1>
+                  """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "getResourceValue", payload
         )
@@ -390,14 +414,17 @@ class IHCSoapClient:
         )
         return IHCSoapClient.__get_value(value)
 
-    def get_runtime_values(self, resourceids):
-        """Get runtime values of specified resource ids
-        Return None if resource cannot be found or on error
+    def get_runtime_values(
+        self, resourceids: list[int]
+    ) -> dict[int, Any] | Literal[False]:
         """
+        Get runtime values of specified resource ids.
 
+        Return None if resource cannot be found or on error
+        """
         idsarr = ""
         for ihcid in resourceids:
-            idsarr += "<arrayItem>{id}</arrayItem>".format(id=ihcid)
+            idsarr += f"<arrayItem>{ihcid}</arrayItem>"
         payload = '<getRuntimeValues1 xmlns="utcs">' + idsarr + "</getRuntimeValues1>"
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "getResourceValues", payload
@@ -412,17 +439,19 @@ class IHCSoapClient:
             ihcid = item.find("ns1:resourceID", IHCSoapClient.ihcns)
             if ihcid is None:
                 continue
-            resourceValue = item.find("./ns1:value", IHCSoapClient.ihcns)
-            itemValue = IHCSoapClient.__get_value(resourceValue)
-            if itemValue is not None:
-                changes[int(ihcid.text)] = itemValue
+            resource_value = item.find("./ns1:value", IHCSoapClient.ihcns)
+            item_value = IHCSoapClient.__get_value(resource_value)
+            if item_value is not None:
+                changes[int(ihcid.text)] = item_value
         return changes
 
-    def cycle_bool_value(self, resourceid: int):
-        """Turn a booelan resource On and back Off
+    def cycle_bool_value(self, resourceid: int) -> bool | None:
+        """
+        Turn a booelan resource On and back Off.
+
         Return None if resource cannot be found or on error
         """
-        setBool = (
+        set_bool = (
             "<arrayItem>"
             '<value xsi:type="ns1:WSBooleanValue">'
             "<ns1:value>{value}</ns1:value>"
@@ -434,8 +463,8 @@ class IHCSoapClient:
         )
         payload = (
             '<setResourceValues1 xmlns="utcs" xmlns:ns1="utcs.values">'
-            + setBool.format(value="true", id=resourceid)
-            + setBool.format(value="false", id=resourceid)
+            + set_bool.format(value="true", id=resourceid)
+            + set_bool.format(value="false", id=resourceid)
             + "</setResourceValues1>"
         )
         xdoc = self.connection.soap_action(
@@ -445,53 +474,53 @@ class IHCSoapClient:
             return None
         return True
 
-    def enable_runtime_notification(self, resourceid: int):
-        """Enable notification for specified resource id"""
+    def enable_runtime_notification(self, resourceid: int) -> bool:
+        """Enable notification for specified resource id."""
         return self.enable_runtime_notifications([resourceid])
 
-    def enable_runtime_notifications(self, resourceids):
-        """Enable notification for specified resource ids"""
+    def enable_runtime_notifications(self, resourceids: list[int]) -> bool:
+        """Enable notification for specified resource ids."""
         idsarr = ""
         for ihcid in resourceids:
-            idsarr += "<a:arrayItem>{id}</a:arrayItem>".format(id=ihcid)
+            idsarr += f"<a:arrayItem>{ihcid}</a:arrayItem>"
 
-        payload = """<enableRuntimeValueNotifications1 xmlns=\"utcs\"
+        payload = f"""<enableRuntimeValueNotifications1 xmlns=\"utcs\"
                      xmlns:a=\"http://www.w3.org/2001/XMLSchema\"
                      xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
-                     {arr}
+                     {idsarr}
                      </enableRuntimeValueNotifications1>
-                     """.format(
-            arr=idsarr
-        )
+                     """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "enableRuntimeValueNotifications", payload
         )
         return xdoc is not False
 
-    def wait_for_resource_value_changes(self, wait: int = 10):
+    def wait_for_resource_value_changes(
+        self, wait: int = 10
+    ) -> dict[int, str] | Literal[False]:
         """
-        Long polling for changes and return a dictionary with resource:value
-        for changes (Only last change)
+        Long polling for changes.
+
+        And return a dictionary with resource:value for changes (Only last change)
         """
         change_list = self.wait_for_resource_value_change_list(wait)
         if change_list is False:
             return False
-        last_changes = {}
-        for id, value in change_list:
-            last_changes[id] = value
-        return last_changes
+        return dict(change_list)
 
-    def wait_for_resource_value_change_list(self, wait: int = 10):
+    def wait_for_resource_value_change_list(
+        self, wait: int = 10
+    ) -> list[(int, Any)] | Literal[False]:
         """
-        Long polling for changes and return a resource id dictionary with a list of all changes since last poll.
+        Long polling for changes.
+
+        And return a resource id dictionary with a list of all changes since last poll.
         Return a list of tuples with the id,value
         """
         changes = []
-        payload = """<waitForResourceValueChanges1
-                     xmlns=\"utcs\">{timeout}</waitForResourceValueChanges1>
-                  """.format(
-            timeout=wait
-        )
+        payload = f"""<waitForResourceValueChanges1
+                     xmlns=\"utcs\">{wait}</waitForResourceValueChanges1>
+                  """
         xdoc = self.connection.soap_action(
             "/ws/ResourceInteractionService", "getResourceValue", payload
         )
@@ -512,14 +541,12 @@ class IHCSoapClient:
                 changes.append((int(ihcid.text), value))
         return changes
 
-    def get_user_log(self, language="da"):
-        """Get the controller state"""
-        payload = """<getUserLog1 xmlns="utcs" />
+    def get_user_log(self, language: str = "da") -> str | Literal[False]:
+        """Get the controller state."""
+        payload = f"""<getUserLog1 xmlns="utcs" />
                      <getUserLog2 xmlns="utcs">0</getUserLog2>
                      <getUserLog3 xmlns="utcs">{language}</getUserLog3>
-                     """.format(
-            language=language
-        )
+                     """
         xdoc = self.connection.soap_action(
             "/ws/ConfigurationService", "getUserLog", payload
         )
@@ -532,52 +559,47 @@ class IHCSoapClient:
             return base64.b64decode(base64data).decode("UTF-8")
         return False
 
-    def clear_user_log(self):
-        """Clear the user log in the controller"""
-        xdoc = self.connection.soap_action(
-            "/ws/ConfigurationService", "clearUserLog", ""
-        )
-        return
+    def clear_user_log(self) -> None:
+        """Clear the user log in the controller."""
+        self.connection.soap_action("/ws/ConfigurationService", "clearUserLog", "")
 
-    def get_system_info(self):
-        """Get controller system info"""
+    def get_system_info(self) -> dict[str, str] | bool:
+        """Get controller system info."""
         xdoc = self.connection.soap_action(
             "/ws/ConfigurationService", "getSystemInfo", ""
         )
         if xdoc is False:
             return False
-        info = {
-            "uptime": IHCSoapClient.__extract_sysinfo(xdoc, "uptime"),
-            "realtimeclock": IHCSoapClient.__extract_sysinfo(xdoc, "realtimeclock"),
-            "serial_number": IHCSoapClient.__extract_sysinfo(xdoc, "serialNumber"),
-            "production_date": IHCSoapClient.__extract_sysinfo(xdoc, "productionDate"),
-            "brand": IHCSoapClient.__extract_sysinfo(xdoc, "brand"),
-            "version": IHCSoapClient.__extract_sysinfo(xdoc, "version"),
-            "hw_revision": IHCSoapClient.__extract_sysinfo(xdoc, "hwRevision"),
-            "sw_date": IHCSoapClient.__extract_sysinfo(xdoc, "swDate"),
-            "dataline_version": IHCSoapClient.__extract_sysinfo(
-                xdoc, "datalineVersion"
-            ),
-            "rf_module_software_version": IHCSoapClient.__extract_sysinfo(
+        return {
+            "uptime": IHCSoapClient._extract_sysinfo(xdoc, "uptime"),
+            "realtimeclock": IHCSoapClient._extract_sysinfo(xdoc, "realtimeclock"),
+            "serial_number": IHCSoapClient._extract_sysinfo(xdoc, "serialNumber"),
+            "production_date": IHCSoapClient._extract_sysinfo(xdoc, "productionDate"),
+            "brand": IHCSoapClient._extract_sysinfo(xdoc, "brand"),
+            "version": IHCSoapClient._extract_sysinfo(xdoc, "version"),
+            "hw_revision": IHCSoapClient._extract_sysinfo(xdoc, "hwRevision"),
+            "sw_date": IHCSoapClient._extract_sysinfo(xdoc, "swDate"),
+            "dataline_version": IHCSoapClient._extract_sysinfo(xdoc, "datalineVersion"),
+            "rf_module_software_version": IHCSoapClient._extract_sysinfo(
                 xdoc, "rfModuleSoftwareVersion"
             ),
-            "rf_module_serial_number": IHCSoapClient.__extract_sysinfo(
+            "rf_module_serial_number": IHCSoapClient._extract_sysinfo(
                 xdoc, "rfModuleSerialNumber"
             ),
-            "application_is_without_viewer": IHCSoapClient.__extract_sysinfo(
+            "application_is_without_viewer": IHCSoapClient._extract_sysinfo(
                 xdoc, "applicationIsWithoutViewer"
             ),
-            "sms_modem_software_version": IHCSoapClient.__extract_sysinfo(
+            "sms_modem_software_version": IHCSoapClient._extract_sysinfo(
                 xdoc, "smsModemSoftwareVersion"
             ),
-            "led_dimmer_software_version": IHCSoapClient.__extract_sysinfo(
+            "led_dimmer_software_version": IHCSoapClient._extract_sysinfo(
                 xdoc, "ledDimmerSoftwareVersion"
             ),
         }
-        return info
 
-    def __extract_sysinfo(xdoc, param) -> str:
-        """Internal function to extrach a parameter from system info"""
+    @staticmethod
+    def _extract_sysinfo(xdoc: ET.Element, param: str) -> str:
+        """Extract a parameter from system info."""
         element = xdoc.find(
             f"./SOAP-ENV:Body/ns1:getSystemInfo1/ns1:{param}", IHCSoapClient.ihcns
         )

ihcsdk/ihcconnection.py

@@ -1,15 +1,21 @@
-"""Implements soap reqeust using the "requests" module"""
-# pylint: disable=too-few-public-methods
-import logging
-import requests
-import xml.etree.ElementTree
+"""Implements soap reqeust using the "requests" module."""
 
+import logging
+import time
+import xml.etree.ElementTree as ET
+from http import HTTPStatus
+from typing import Literal
 from urllib.parse import urlparse
 
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
+
 _LOGGER = logging.getLogger(__name__)
 
-class IHCConnection(object):
-    """Implements a http connection to the controller"""
+
+class IHCConnection:
+    """Implements a http connection to the controller."""
 
     soapenvelope = """<?xml version=\"1.0\" encoding=\"UTF-8\"?>
         <s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"
@@ -17,18 +23,37 @@ class IHCConnection(object):
           xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">
         <s:Body>{body}</s:Body></s:Envelope>"""
 
-    def __init__(self, url: str):
-        """Initialize the IHCConnection with a url for the controller"""
+    def __init__(self, url: str) -> None:
+        """Initialize the IHCConnection with a url for the controller."""
         self.url = url
         self.verify = False
         self.last_exception = None
         self.last_response = None
         self.session = requests.Session()
+        self.retries = Retry(
+            total=3,
+            backoff_factor=0.2,
+            status_forcelist=[502, 503, 504],
+            allowed_methods={"POST"},
+        )
+        self.session.mount("http://", HTTPAdapter(max_retries=self.retries))
+        # default minimum time between calls in seconds (0 will not rate limit)
+        self.min_interval: float = 0.0
+        self.last_call_time: float = 0
+        self.logtiming = False
 
-    def cert_verify(self):
+    def close(self) -> None:
+        """Close the connection."""
+        self.session.close()
+        self.session = None
+
+    def cert_verify(self) -> str | None:
+        """Validate the certificate and return the cert file."""
         return None
 
-    def soap_action(self, service, action, payloadbody):
+    def soap_action(
+        self, service: str, action: str, payloadbody: str
+    ) -> ET.Element | Literal[False]:
         """Do a soap request."""
         payload = self.soapenvelope.format(body=payloadbody).encode("utf-8")
         headers = {
@@ -39,7 +64,8 @@ class IHCConnection(object):
             "SOAPAction": action,
         }
         try:
-            _LOGGER.debug( "soap payload %s",payload)
+            self.rate_limit()
+            _LOGGER.debug("soap payload %s", payload)
             self.last_exception = None
             response = self.session.post(
                 url=self.url + service,
@@ -47,22 +73,35 @@ class IHCConnection(object):
                 data=payload,
                 verify=self.cert_verify(),
             )
-            _LOGGER.debug( "soap request response status %d",response.status_code)
-        except requests.exceptions.RequestException as exp:
-            _LOGGER.error( "soap request exception %s",exp)
-            self.last_exception = exp
-            return False
-        if response.status_code != 200:
-            self.last_response = response
-            return False
-        try:
-            _LOGGER.debug( "soap request response %s",response.text)
-            xdoc = xml.etree.ElementTree.fromstring(response.text)
+            _LOGGER.debug("soap request response status %d", response.status_code)
+            if response.status_code != HTTPStatus.OK:
+                self.last_response = response
+                return False
+            _LOGGER.debug("soap request response %s", response.text)
+            xdoc = ET.fromstring(response.text)  # noqa: S314
             if xdoc is None:
                 return False
-        except xml.etree.ElementTree.ParseError as exp:
-            _LOGGER.error( "soap request xml parse error %s",exp)
+        except requests.exceptions.RequestException as exp:
+            _LOGGER.exception("soap request exception")
+            self.last_exception = exp
+        except ET.ParseError as exp:
+            _LOGGER.exception("soap request xml parse erro")
             self.last_exception = exp
             self.last_response = response
-            return False
-        return xdoc
+        else:
+            return xdoc
+        return False
+
+    def rate_limit(self) -> None:
+        """Rate limit the calls to this function."""
+        current_time: float = time.time()
+        time_since_last_call: float = current_time - self.last_call_time
+        if self.logtiming:
+            _LOGGER.warning("time since last call %f sec", time_since_last_call)
+        # If not enough time has passed, sleep for the remaining time
+        if time_since_last_call < self.min_interval:
+            sleep_time: float = self.min_interval - time_since_last_call
+            _LOGGER.debug("Ratelimiting for %f sec", sleep_time)
+            time.sleep(sleep_time)
+        # Update the last call time and call the function
+        self.last_call_time = time.time()

ihcsdk/ihccontroller.py

@@ -1,28 +1,36 @@
 """
-Wraps the ihcclient in a more user friendly interface to handle lost connection
+Wraps the ihcclient in a more user friendly interface to handle lost connection.
+
 Notify thread to handle change notifications
 """
 
 # pylint: disable=invalid-name, bare-except, too-many-instance-attributes
-from datetime import datetime, timedelta
 import logging
-import requests
 import threading
 import time
-from ihcsdk.ihcclient import IHCSoapClient, IHCSTATE_READY
+from collections.abc import Callable
+from datetime import datetime, timedelta
+from http import HTTPStatus
+from typing import Any, Literal
+
+import requests
+
+from ihcsdk.ihcclient import IHCSTATE_READY, IHCSoapClient
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class IHCController:
     """
-    Implements the notification thread and
+    Implements the notification thread.
+
     will re-authenticate if needed.
     """
 
     _mutex = threading.Lock()
 
-    def __init__(self, url: str, username: str, password: str):
+    def __init__(self, url: str, username: str, password: str) -> None:
+        """Initialize the IHC controller with connection data."""
         self.client = IHCSoapClient(url)
         self.reauthenticatetimeout = 30
         self.retryinterval = 10
@@ -35,26 +43,26 @@ class IHCController:
         self._newnotifyids = []
         self._project = None
 
+    @staticmethod
     def is_ihc_controller(url: str) -> bool:
         """Will return True if the url respods like an IHC controller."""
         try:
             client = IHCSoapClient(url)
             response = client.connection.session.get(
-                f"{url}/wsdl/controller.wsdl", verify=client.connection.cert_verify()
+                f"{url}/wsdl/controller.wsdl", verify=False
             )
-            if response.status_code != 200:
+            client.close()
+            if response.status_code != HTTPStatus.OK:
                 return False
             if not response.headers["content-type"].startswith("text/xml"):
                 return False
-            if response.text.find("getIHCProject") < 0:
-                return False
-            return True
+            return not response.text.find("getIHCProject") < 0
         except requests.exceptions.RequestException as exp:
             _LOGGER.warning("is_ihc_controller %s", exp)
             return False
 
     def authenticate(self) -> bool:
-        """Authenticate and enable the registered notifications"""
+        """Authenticate and enable the registered notifications."""
         with IHCController._mutex:
             _LOGGER.debug("Authenticating login on ihc controller")
             if not self.client.authenticate(self._username, self._password):
@@ -65,30 +73,34 @@ class IHCController:
                 self.client.enable_runtime_notifications(self._ihcevents.keys())
             return True
 
-    def disconnect(self):
-        """Disconnect by stopping the notification thread
-        TODO call disconnect on ihcclient
-        """
+    def disconnect(self) -> None:
+        """Disconnect by stopping the notification thread. And closing the client."""
         self._notifyrunning = False
-
-    def get_runtime_value(self, ihcid: int):
-        """Get runtime value with re-authenticate if needed"""
+        # wait for notify thread to finish
+        while self._notifythread.is_alive():
+            time.sleep(0.1)  # Optional sleep to prevent busy waiting
+        self.client.close()
+
+    def get_runtime_value(
+        self, ihcid: int
+    ) -> bool | int | float | str | datetime | None:
+        """Get runtime value with re-authenticate if needed."""
         value = self.client.get_runtime_value(ihcid)
         if value is not None:
             return value
         self.re_authenticate()
         return self.client.get_runtime_value(ihcid)
 
-    def get_runtime_values(self, ihcids):
-        """Get runtime value with re-authenticate if needed"""
+    def get_runtime_values(self, ihcids: list[int]) -> dict[int, Any] | Literal[False]:
+        """Get runtime value with re-authenticate if needed."""
         value = self.client.get_runtime_values(ihcids)
         if value is not None:
             return value
         self.re_authenticate()
         return self.client.get_runtime_values(ihcids)
 
-    def cycle_bool_value(self, resourceid: int):
-        """Turn a booelan resource On and back Off"""
+    def cycle_bool_value(self, resourceid: int) -> bool | None:
+        """Turn a booelan resource On and back Off."""
         value = self.client.cycle_bool_value(resourceid)
         if value is not None:
             return value
@@ -96,28 +108,28 @@ class IHCController:
         return self.client.cycle_bool_value(resourceid)
 
     def set_runtime_value_bool(self, ihcid: int, value: bool) -> bool:
-        """Set bool runtime value with re-authenticate if needed"""
+        """Set bool runtime value with re-authenticate if needed."""
         if self.client.set_runtime_value_bool(ihcid, value):
             return True
         self.re_authenticate()
         return self.client.set_runtime_value_bool(ihcid, value)
 
     def set_runtime_value_int(self, ihcid: int, value: int) -> bool:
-        """Set integer runtime value with re-authenticate if needed"""
+        """Set integer runtime value with re-authenticate if needed."""
         if self.client.set_runtime_value_int(ihcid, value):
             return True
         self.re_authenticate()
         return self.client.set_runtime_value_int(ihcid, value)
 
     def set_runtime_value_float(self, ihcid: int, value: float) -> bool:
-        """Set float runtime value with re-authenticate if needed"""
+        """Set float runtime value with re-authenticate if needed."""
         if self.client.set_runtime_value_float(ihcid, value):
             return True
         self.re_authenticate()
         return self.client.set_runtime_value_float(ihcid, value)
 
     def set_runtime_value_timer(self, ihcid: int, value: int) -> bool:
-        """Set timer runtime value with re-authenticate if needed"""
+        """Set timer runtime value with re-authenticate if needed."""
         if self.client.set_runtime_value_timer(ihcid, value):
             return True
         self.re_authenticate()
@@ -126,14 +138,14 @@ class IHCController:
     def set_runtime_value_time(
         self, ihcid: int, hours: int, minutes: int, seconds: int
     ) -> bool:
-        """Set time runtime value with re-authenticate if needed"""
+        """Set time runtime value with re-authenticate if needed."""
         if self.client.set_runtime_value_time(ihcid, hours, minutes):
             return True
         self.re_authenticate()
         return self.client.set_runtime_value_time(ihcid, hours, minutes, seconds)
 
     def get_project(self, insegments: bool = True) -> str:
-        """Get the ihc project and make sure controller is ready before"""
+        """Get the ihc project and make sure controller is ready before."""
         with IHCController._mutex:
             if self._project is None:
                 if self.client.get_state() != IHCSTATE_READY:
@@ -146,8 +158,15 @@ class IHCController:
                     self._project = self.client.get_project()
         return self._project
 
-    def add_notify_event(self, resourceid: int, callback, delayed=False):
-        """Add a notify callback for a specified resource id
+    def add_notify_event(
+        self,
+        resourceid: int,
+        callback: Callable[[int, bool | float | str | datetime], None],
+        delayed: bool = False,
+    ) -> bool:
+        """
+        Add a notify callback for a specified resource id.
+
         If delayed is set to true the enable request will be send from the
         notofication thread
         """
@@ -158,17 +177,16 @@ class IHCController:
                 self._ihcevents[resourceid] = [callback]
                 if delayed:
                     self._newnotifyids.append(resourceid)
-                else:
-                    if not self.client.enable_runtime_notification(resourceid):
-                        return False
+                elif not self.client.enable_runtime_notification(resourceid):
+                    return False
             if not self._notifyrunning:
                 self._notifyrunning = True
                 self._notifythread.start()
 
             return True
 
-    def _notify_fn(self):
-        """The notify thread function."""
+    def _notify_fn(self) -> None:
+        """Notify thread function."""
         _LOGGER.debug("Starting notify thread")
         while self._notifyrunning:
             try:
@@ -180,7 +198,7 @@ class IHCController:
 
                 changes = self.client.wait_for_resource_value_change_list()
                 if changes is False:
-                    self.re_authenticate(True)
+                    self.re_authenticate(notify=True)
                     continue
                 for ihcid, value in changes:
                     if ihcid in self._ihcevents:
@@ -191,32 +209,33 @@ class IHCController:
                             ):
                                 callback(ihcid, value)
                             self._ihcvalues[ihcid] = value
-            except Exception as exp:
-                _LOGGER.error("Exception in notify thread %s", exp)
-                self.re_authenticate(True)
+            except Exception:
+                _LOGGER.exception("Exception in notify thread")
+                self.re_authenticate(notify=True)
 
     def re_authenticate(self, notify: bool = False) -> bool:
-        """Authenticate again after failure.
+        """
+        Authenticate again after failure.
+
         Keep trying with 10 sec interval. If called from the notify thread
         we will not have a timeout, but will end if the notify thread has
         been cancled.
         Will return True if authentication was successful.
         """
-        timeout = datetime.now() + timedelta(seconds=self.reauthenticatetimeout)
+        timeout = datetime.now() + timedelta(seconds=self.reauthenticatetimeout)  # noqa: DTZ005
         while True:
             _LOGGER.debug("Reauthenticating login on ihc controller")
             if self.authenticate():
                 return True
             _LOGGER.debug(
-                "Authenticate failed - Reauthenticating login on ihc controller in 10 sec"
+                "Authenticate failed, reauthenticating login on ihc controller in 10s"
             )
 
             # if called from the notify and notify a cancled we do not want to retry
             if notify:
                 if not self._notifyrunning:
                     return False
-            else:
-                if timeout and datetime.now() > timeout:
-                    return False
+            elif timeout and datetime.now() > timeout:  # noqa: DTZ005
+                return False
             # wait before we try to authenticate again
             time.sleep(self.retryinterval)

ihcsdk/ihcsslconnection.py

@@ -1,47 +1,50 @@
-"""Implements soap reqeust using the "requests" module"""
+"""Implements soap reqeust using the "requests" module."""
+
 # pylint: disable=too-few-public-methods
 import os
-import requests
 
-from cryptography.x509 import load_pem_x509_certificate
+import requests
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes
-from requests.adapters import HTTPAdapter
+from cryptography.x509 import load_pem_x509_certificate
 from requests.packages.urllib3.util.ssl_ import create_urllib3_context
 
 from ihcsdk.ihcconnection import IHCConnection
 
 
 class IHCSSLConnection(IHCConnection):
-    """Implements a https connection to the controller"""
+    """Implements a https connection to the controller."""
 
-    def __init__(self, url: str):
-        """Initialize the IHCSSLConnection with a url for the controller"""
-        super(IHCSSLConnection, self).__init__(url)
+    def __init__(self, url: str) -> None:
+        """Initialize the IHCSSLConnection with a url for the controller."""
+        super().__init__(url)
         self.cert_file = os.path.dirname(__file__) + "/certs/ihc3.crt"
-        self.session.mount("https://", CertAdapter(self.get_fingerprint_from_cert()))
+        self.session.mount(
+            "https://",
+            CertAdapter(self.get_fingerprint_from_cert(), max_retries=self.retries),
+        )
 
-    def get_fingerprint_from_cert(self):
-        """Get the fingerprint from the certificate"""
+    def get_fingerprint_from_cert(self) -> str:
+        """Get the fingerprint from the certificate."""
         pem = open(self.cert_file, "rb").read()
         cert = load_pem_x509_certificate(pem, default_backend())
         f = cert.fingerprint(hashes.SHA1())
         return "".join("{:02x}".format(x) for x in f)
 
-    def cert_verify(self):
+    def cert_verify(self) -> str:
         return self.cert_file
 
 
 class CertAdapter(requests.adapters.HTTPAdapter):
-    """A adapter for a specific certificate"""
+    """A adapter for a specific certificate."""
 
-    def __init__(self, fingerprint, **kwargs):
-        """Constructor. Store the fingerprint for use when creating the poolmanager."""
+    def __init__(self, fingerprint, **kwargs) -> None:
+        """Store the fingerprint for use when creating the poolmanager."""
         self.fingerprint = fingerprint
-        super(CertAdapter, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 
     def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs):
-        """Create a custom poolmanager"""
+        """Create a custom poolmanager."""
         CIPHERS = "DEFAULT:!DH"
         context = create_urllib3_context(ciphers=CIPHERS)
         pool_kwargs["ssl_context"] = context

{ihcsdk-2.8.7.dist-info → ihcsdk-2.8.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ihcsdk
-Version: 2.8.7
+Version: 2.8.11
 Summary: IHC Python SDK
 Home-page: https://github.com/dingusdk/PythonIhcSdk
 Author: Jens Nielsen
@@ -8,5 +8,12 @@ License: GPL-3.0
 License-File: license.txt
 Requires-Dist: requests
 Requires-Dist: cryptography
+Dynamic: author
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 SDK for connection to the LK IHC Controller. Made for interfacing to home assistant

ihcsdk-2.8.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+ihcsdk/__init__.py,sha256=IFv4tTt5vulfQlTqcok2IJA8ms3rE7XR7WIsRM2az9g,28
+ihcsdk/ihcclient.py,sha256=NyTKFaF_jz5x1_fz1bHna22ke7KRm4DukMqn3aE70nM,24970
+ihcsdk/ihcconnection.py,sha256=ISruHcCqusn5KCVSBwE8LNJS-v0aIw89WPCxAQuIk4w,4133
+ihcsdk/ihccontroller.py,sha256=wb-7y5J0arNrlCMi35I6CLYwtKgcJvLNmzaABHqW3Aw,9767
+ihcsdk/ihcsslconnection.py,sha256=OjGo8eJGHFnhVc9nz0Krf6mCCVrOOWj9BpTDOTtxKqk,2063
+ihcsdk/certs/ihc.crt,sha256=VYY_DiHrctlXBTNXGdJ2FN4TYuVnwnpVZ1i8t2_0cec,1002
+ihcsdk/certs/ihc3.crt,sha256=Ka2L8zQ06A76W6fZc0ckScdrj1Cn-mhgqdhc61-cCrk,1398
+ihcsdk-2.8.11.dist-info/licenses/license.txt,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+ihcsdk-2.8.11.dist-info/METADATA,sha256=qUKqMaLYOBUsmAhn7jIvlGydjIqFz6Ohu_63qUiaG9E,482
+ihcsdk-2.8.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ihcsdk-2.8.11.dist-info/top_level.txt,sha256=QgKE7TWblC-uXe5-7MVO5JtzvrPiMoVmGgKKsVR43hU,7
+ihcsdk-2.8.11.dist-info/RECORD,,

{ihcsdk-2.8.7.dist-info → ihcsdk-2.8.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ihcsdk-2.8.7.dist-info/RECORD

@@ -1,12 +0,0 @@
-ihcsdk/__init__.py,sha256=ocAoa28ZKxGgMlDEHWEsd7n00OtGB0R9N7XQfRlih9Q,28
-ihcsdk/ihcclient.py,sha256=KCgat4CnR69Vrb-GdA9tfduS7tQl9ymwqEBf-EPDM1U,24117
-ihcsdk/ihcconnection.py,sha256=qnOEEsgKulIUGRS223o9YSy9qmEVR1D6jNt2XxGFGho,2577
-ihcsdk/ihccontroller.py,sha256=9D97RX8DrFMLMxDBcIrhoYY-QEeKNjbVv_PiRW0wNyU,9180
-ihcsdk/ihcsslconnection.py,sha256=4IFVg1bpdJ25yN76tnFLndvL5Rl9-qbXrbENUjyTfzw,2056
-ihcsdk/certs/ihc.crt,sha256=VYY_DiHrctlXBTNXGdJ2FN4TYuVnwnpVZ1i8t2_0cec,1002
-ihcsdk/certs/ihc3.crt,sha256=Ka2L8zQ06A76W6fZc0ckScdrj1Cn-mhgqdhc61-cCrk,1398
-ihcsdk-2.8.7.dist-info/METADATA,sha256=q8VRbllNSE39vfayX1ui00DurTtIACN24dL7WJ0XVCY,339
-ihcsdk-2.8.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ihcsdk-2.8.7.dist-info/license.txt,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-ihcsdk-2.8.7.dist-info/top_level.txt,sha256=QgKE7TWblC-uXe5-7MVO5JtzvrPiMoVmGgKKsVR43hU,7
-ihcsdk-2.8.7.dist-info/RECORD,,