pyasyncialarm 2.3.0__py3-none-any.whl

pyasyncialarm/__init__.py

@@ -0,0 +1,3 @@
+"""Python Library for interacting with IAlarm aka antifurto365 alarm."""
+
+name = "pyasyncialarm"

pyasyncialarm/const.py

@@ -0,0 +1,168 @@
+"""Constants for iAlarm Home Assistant Integration."""
+
+from datetime import datetime
+from enum import Enum, IntEnum
+from typing import Optional, TypedDict
+
+
+class LogEntryType(TypedDict):
+    time: Optional[datetime]
+    area: int
+    event: str
+    name: str
+
+
+class LogEntryTypeRaw(TypedDict):
+    Time: str
+    Area: int
+    Event: str
+    Name: str
+
+
+EVENT_TYPE_MAP = {
+    "0000": "Unused",
+    "1100": "Personal ambulance",
+    "1101": "Emergency",
+    "1110": "Fire",
+    "1113": "Water",
+    "1120": "Emergency",
+    "1121": "Duress alarm",
+    "1122": "Personal ambulance",
+    "1131": "Perimeter",
+    "1132": "Burglary",
+    "1133": "24 hour",
+    "1134": "Delay",
+    "1137": "Dismantled",
+    "1151": "Gas",
+    "1154": "Water intrusion alarm",
+    "1301": "System AC fault",
+    "1302": "System battery failure",
+    "1306": "Programming changes",
+    "1321": "Siren fault",
+    "1350": "Communication failure",
+    "1351": "Telephone line fault",
+    "1370": "Circuit fault",
+    "1381": "Detector lost",
+    "1384": "Detector low battery",
+    "1401": "Disarm report",
+    "1406": "Alarm canceled",
+    "1455": "Automatic arming failed",
+    "1570": "Bypass Report",
+    "1601": "Manual communication test reports",
+    "1602": "Communications test reports",
+    "1901": "Gate magnetic switch open",
+    "3100": "Personal ambulance recovery",
+    "3110": "Fire recovery",
+    "3120": "Emergency recovery",
+    "3122": "Personal Ambulance Recovery",
+    "3131": "Perimeter recovery",
+    "3132": "Burglary recovery",
+    "3133": "24 hour recovery",
+    "3134": "Alarm delay recovery",
+    "3137": "Dismantled recovery",
+    "3301": "System AC recovery",
+    "3302": "System battery recovery",
+    "3321": "Siren recovery",
+    "3350": "Communication recovery",
+    "3351": "Telephone line to restore",
+    "3370": "Circuit recovery",
+    "3381": "Detector loss recovery",
+    "3384": "Detector low voltage recovery",
+    "3401": "Arming Report",
+    "3441": "Staying Report",
+    "3570": "Bypass recovery",
+    "3901": "Gate magnetic switch close",
+    "3994": "Video lost recovery",
+    "3995": "Video cover recovery",
+    "9984": "Video lost",
+    "9988": "Full hard disk",
+    "9991": "Hard disk format",
+    "9994": "Video lost",
+    "9995": "Video cover",
+    "9996": "Hard disk lost",
+    "9997": "Hard disk error",
+    "9999": "Motion detection",
+}
+
+
+class StatusType(IntEnum):
+    ZONE_NOT_USED = 0
+    ZONE_IN_USE = 1 << 0
+    ZONE_ALARM = 1 << 1
+    ZONE_BYPASS = 1 << 2
+    ZONE_FAULT = 1 << 3
+    ZONE_LOW_BATTERY = 1 << 4
+    ZONE_LOSS = 1 << 5
+
+
+class ZoneStatusType(TypedDict):
+    zone_id: int
+    name: str
+    types: list[StatusType]
+
+
+class ZoneTypeEnum(str, Enum):
+    UNUSED = "Unused"
+    DELAY = "Delay"
+    PERIMETER = "Perimeter"
+    INNER = "Inner"
+    EMERGENCY = "Emergency"
+    HOUR_24 = "24 Hour"
+    FIRE = "Fire"
+    KEY = "Key"
+    GAS = "Gas"
+    WATER = "Water"
+
+
+class SirenSoundTypeEnum(str, Enum):
+    CONTINUED = "Continued"
+    PULSED = "Pulsed"
+    MUTE = "Mute"
+
+
+TYPE_MAPPING = {
+    0: ZoneTypeEnum.UNUSED,
+    1: ZoneTypeEnum.DELAY,
+    2: ZoneTypeEnum.PERIMETER,
+    3: ZoneTypeEnum.INNER,
+    4: ZoneTypeEnum.EMERGENCY,
+    5: ZoneTypeEnum.HOUR_24,
+    6: ZoneTypeEnum.FIRE,
+    7: ZoneTypeEnum.KEY,
+    8: ZoneTypeEnum.GAS,
+    9: ZoneTypeEnum.WATER,
+}
+
+ZONE_TYPE_MAP = {
+    "NO": ZoneTypeEnum.UNUSED,
+    "DE": ZoneTypeEnum.DELAY,
+    "SI": ZoneTypeEnum.PERIMETER,
+    "IN": ZoneTypeEnum.INNER,
+    "FO": ZoneTypeEnum.EMERGENCY,
+    "HO24": ZoneTypeEnum.HOUR_24,
+    "FI": ZoneTypeEnum.FIRE,
+    "KE": ZoneTypeEnum.KEY,
+    "GAS": ZoneTypeEnum.GAS,
+    "WT": ZoneTypeEnum.WATER,
+}
+
+ALARM_TYPE_MAP = {
+    "CX": SirenSoundTypeEnum.CONTINUED,
+    "MC": SirenSoundTypeEnum.PULSED,
+    "NO": SirenSoundTypeEnum.MUTE,
+}
+
+
+class ZoneType(TypedDict):
+    zone_id: int
+    type: int
+    voice: int
+    name: str
+    bell: bool
+
+
+class ZoneTypeRaw(TypedDict):
+    Type: int
+    Voice: int
+    Name: str
+    Bell: str

pyasyncialarm/exception.py

@@ -0,0 +1,14 @@
+"""Exceptions for iAlarm Home Assistant Integration."""
+
+class IAlarmSocketNotOpenError(ConnectionError):
+    """Exception raised when socket is not open."""
+
+    def __init__(self):
+        super().__init__("Socket is not open")
+
+
+class IAlarmConnectionError(ConnectionError):
+    """Exception raised when socket is not open."""
+
+    def __init__(self):
+        super().__init__("Connection to the alarm system failed")

pyasyncialarm/pyasyncialarm.py

@@ -0,0 +1,432 @@
+import asyncio
+from collections import OrderedDict
+import logging
+import re
+import socket
+from typing import Any, Optional
+
+import dicttoxml2
+import xmltodict
+
+from pyasyncialarm.const import (
+    ALARM_TYPE_MAP,
+    EVENT_TYPE_MAP,
+    ZONE_TYPE_MAP,
+    LogEntryType,
+    LogEntryTypeRaw,
+    SirenSoundTypeEnum,
+    StatusType,
+    ZoneStatusType,
+    ZoneType,
+    ZoneTypeEnum,
+    ZoneTypeRaw,
+)
+from pyasyncialarm.exception import IAlarmConnectionError
+from pyasyncialarm.util import decode_name, parse_bell, parse_time
+
+log = logging.getLogger(__name__)
+# dicttoxml is very verbose at INFO level
+logging.getLogger("dicttoxml").setLevel(logging.CRITICAL)
+
+
+class IAlarm:
+    """Interface the iAlarm security systems."""
+
+    ARMED_AWAY = 0
+    DISARMED = 1
+    ARMED_STAY = 2
+    CANCEL = 3
+    TRIGGERED = 4
+
+    def __init__(self, host, port=18034):
+        """:param host: host of the iAlarm security system (e.g. its IP address)
+        :param port: port of the iAlarm security system (should be '18034')
+        """
+        self.host = host
+        self.port = port
+        self.seq = 0
+        self.sock = None
+
+    def _is_socket_open(self) -> bool:
+        return self.sock is not None and self.sock.fileno() != -1
+
+    async def ensure_connection_is_open(self) -> None:
+        if not self._is_socket_open():
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.setblocking(False)
+
+            self.seq = 0
+            loop = asyncio.get_running_loop()
+            try:
+                await loop.sock_connect(self.sock, (self.host, self.port))
+            except (TimeoutError, OSError, ConnectionRefusedError) as err:
+                self._close_connection()
+                raise IAlarmConnectionError from err
+            except Exception:
+                self._close_connection()
+                raise
+        else:
+            log.debug("Socket is already connected.")
+
+    def _close_connection(self) -> None:
+        if self.sock and self.sock.fileno() != -1:
+            self.sock.close()
+
+    async def _receive(self):
+        def raise_connection_error(msg: str):
+            self._close_connection()
+            raise ConnectionError(msg)
+
+        if not self._is_socket_open():
+            raise_connection_error("Socket is not open")
+
+        try:
+            self.sock.setblocking(False)
+            loop = asyncio.get_running_loop()
+            data = await loop.sock_recv(self.sock, 1024)
+
+            if not data:
+                raise_connection_error("Connection error, received no reply")
+
+        except Exception:
+            self._close_connection()
+            raise
+
+        payload = data[16:-4]
+        decoded = (
+            self._xor(payload).decode(errors="ignore").replace("<Err>ERR|00</Err>", "")
+        )
+
+        log.debug("Decoded data: %s", decoded)
+
+        if not decoded:
+            raise_connection_error("Connection error, received an unexpected reply")
+
+        return xmltodict.parse(
+            decoded,
+            xml_attribs=False,
+            dict_constructor=dict,
+            postprocessor=self._xmlread,
+        )
+
+    async def _send_request_list(
+        self,
+        xpath: str,
+        command: OrderedDict[str, Optional[Any]],
+        offset: int = 0,
+        partial_list: Optional[list[Any]] = None,
+    ) -> list[Any]:
+        if offset > 0:
+            command["Offset"] = "S32,0,0|%d" % offset
+        root_dict: dict[str, Any] = self._create_root_dict(xpath, command)
+        await self._send_dict(root_dict)
+        response: dict[str, Any] = await self._receive()
+
+        if partial_list is None:
+            partial_list = []
+        total: int = self._clean_response_dict(response, f"{xpath}/Total")
+        ln: int = self._clean_response_dict(response, f"{xpath}/Ln")
+        for i in range(ln):
+            partial_list.append(self._clean_response_dict(response, f"{xpath}/L{i}"))
+        offset += ln
+        if total > offset:
+            await self._send_request_list(xpath, command, offset, partial_list)
+
+        return partial_list
+
+    async def _send_request(
+        self, xpath: str, command: OrderedDict[str, Optional[Any]]
+    ) -> dict[str, Any]:
+        root_dict = self._create_root_dict(xpath, command)
+        await self._send_dict(root_dict)
+        response = await self._receive()
+        self._close_connection()
+        return self._clean_response_dict(response, xpath)
+
+    async def get_mac(self) -> str:
+        mac = ""
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Mac"] = None
+        command["Name"] = None
+        command["Ip"] = None
+        command["Gate"] = None
+        command["Subnet"] = None
+        command["Dns1"] = None
+        command["Dns2"] = None
+        command["Err"] = None
+        network_info = await self._send_request("/Root/Host/GetNet", command)
+
+        if network_info is not None:
+            mac = network_info.get("Mac", "")
+
+        if mac:
+            return mac
+        error_message = (
+            "An error occurred trying to connect to the alarm system or received an"
+            " unexpected reply"
+        )
+        raise ConnectionError(error_message)
+
+    async def get_last_log_entries(self, max_entries: int = 25) -> list[LogEntryType]:
+        log_list = await self.get_log()
+        if not log_list:
+            return []
+        return log_list[:max_entries]
+
+    async def get_zone_status(self) -> list[ZoneStatusType]:
+        zones: list[ZoneType] = await self.get_zone()
+
+        zone_name_map = {zone["zone_id"]: zone["name"] for zone in zones}
+
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Total"] = None
+        command["Offset"] = "S32,0,0|0"
+        command["Ln"] = None
+        command["Err"] = None
+        zone_status: list[int] = await self._send_request_list(
+            "/Root/Host/GetByWay", command
+        )
+
+        if zone_status is None:
+            error_message = "An error occurred trying to connect to the alarm system"
+            raise ConnectionError(error_message)
+
+        result = []
+        for i, status in enumerate(zone_status):
+            zone_id = i + 1
+
+            status_list = []
+
+            if status & StatusType.ZONE_IN_USE:
+                status_list.append(StatusType.ZONE_IN_USE)
+            if status & StatusType.ZONE_ALARM:
+                status_list.append(StatusType.ZONE_ALARM)
+            if status & StatusType.ZONE_BYPASS:
+                status_list.append(StatusType.ZONE_BYPASS)
+            if status & StatusType.ZONE_FAULT:
+                status_list.append(StatusType.ZONE_FAULT)
+            if status & StatusType.ZONE_LOW_BATTERY:
+                status_list.append(StatusType.ZONE_LOW_BATTERY)
+            if status & StatusType.ZONE_LOSS:
+                status_list.append(StatusType.ZONE_LOSS)
+
+            if not status_list:
+                status_list.append(StatusType.ZONE_NOT_USED)
+
+            zone_name = zone_name_map.get(zone_id, "Unknown")
+
+            zone_item: ZoneStatusType = {
+                "zone_id": zone_id,
+                "name": zone_name,
+                "types": status_list,
+            }
+            result.append(zone_item)
+
+        return result
+
+    async def get_status(self) -> int:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["DevStatus"] = None
+        command["Err"] = None
+
+        alarm_status: dict[str, Any] = await self._send_request(
+            "/Root/Host/GetAlarmStatus", command
+        )
+
+        if alarm_status is None:
+            error_message = "An error occurred trying to connect to the alarm system"
+            raise ConnectionError(error_message)
+
+        status = int(alarm_status.get("DevStatus", -1))
+        if status == -1:
+            error_message = "Received an unexpected reply from the alarm"
+            raise ConnectionError(error_message)
+
+        if status in {self.ARMED_AWAY, self.ARMED_STAY}:
+            zone_status: list[ZoneStatusType] = await self.get_zone_status()
+            zone_alarm = any(
+                StatusType.ZONE_ALARM in zone["types"] for zone in zone_status
+            )
+
+            if zone_alarm:
+                return self.TRIGGERED
+
+        return status
+
+    async def get_log(self) -> list[LogEntryType]:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Total"] = None
+        command["Offset"] = "S32,0,0|0"
+        command["Ln"] = None
+        command["Err"] = None
+
+        event_log_raw: list[LogEntryTypeRaw] = await self._send_request_list(
+            "/Root/Host/GetLog", command
+        )
+
+        logs = [
+            LogEntryType(
+                time=parse_time(event["Time"]),
+                area=event["Area"],
+                event=EVENT_TYPE_MAP.get(event["Event"], event["Event"]),
+                name=decode_name(event["Name"]),
+            )
+            for event in event_log_raw
+        ]
+
+        return logs
+
+    def __extract_zones(self, zone_data_raw: list[ZoneTypeRaw]) -> list[ZoneType]:
+        return [
+            ZoneType(
+                zone_id=i,
+                type=zone["Type"],
+                voice=zone["Voice"],
+                name=decode_name(zone["Name"]),
+                bell=parse_bell(zone["Bell"]),
+            )
+            for i, zone in enumerate(zone_data_raw, start=1)
+        ]
+
+    async def get_zone(self) -> list[ZoneType]:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Total"] = None
+        command["Offset"] = "S32,0,0|0"
+        command["Ln"] = None
+        command["Err"] = None
+
+        raw_zone_data: list[ZoneTypeRaw] = await self._send_request_list(
+            "/Root/Host/GetZone", command
+        )
+        zone: list[ZoneType] = self.__extract_zones(raw_zone_data)
+
+        return zone
+
+    async def get_zone_type(self) -> list[ZoneTypeEnum]:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Total"] = None
+        command["Offset"] = "S32,0,0|0"
+        command["Ln"] = None
+        command["Err"] = None
+
+        zone_type_codes = await self._send_request_list(
+            "/Root/Host/GetZoneType", command
+        )
+        zone_types = [
+            ZONE_TYPE_MAP.get(code, ZoneTypeEnum.UNUSED) for code in zone_type_codes
+        ]
+
+        return zone_types
+
+    async def get_alarm_type(self) -> list[SirenSoundTypeEnum]:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["Total"] = None
+        command["Offset"] = "S32,0,0|0"
+        command["Ln"] = None
+        command["Err"] = None
+
+        alarm_type_codes = await self._send_request_list(
+            "/Root/Host/GetVoiceType", command
+        )
+        zone_types = [
+            ALARM_TYPE_MAP.get(code, SirenSoundTypeEnum.CONTINUED)
+            for code in alarm_type_codes
+        ]
+
+        return zone_types
+
+    async def arm_away(self) -> None:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["DevStatus"] = "TYP,ARM|0"
+        command["Err"] = None
+        await self._send_request("/Root/Host/SetAlarmStatus", command)
+
+    async def arm_stay(self) -> None:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["DevStatus"] = "TYP,STAY|2"
+        command["Err"] = None
+        await self._send_request("/Root/Host/SetAlarmStatus", command)
+
+    async def disarm(self) -> None:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["DevStatus"] = "TYP,DISARM|1"
+        command["Err"] = None
+        await self._send_request("/Root/Host/SetAlarmStatus", command)
+
+    async def cancel_alarm(self) -> None:
+        command: OrderedDict[str, Optional[Any]] = OrderedDict()
+        command["DevStatus"] = "TYP,CLEAR|3"
+        command["Err"] = None
+        await self._send_request("/Root/Host/SetAlarmStatus", command)
+
+    async def _send_dict(self, root_dict) -> None:
+        xml = dicttoxml2.dicttoxml(root_dict, attr_type=False, root=False)
+
+        await self.ensure_connection_is_open()
+
+        self.seq += 1
+        msg = b"@ieM%04d%04d0000%s%04d" % (len(xml), self.seq, self._xor(xml), self.seq)
+
+        loop = asyncio.get_running_loop()
+        await loop.sock_sendall(self.sock, msg)
+
+    @staticmethod
+    def _xmlread(_path, key, value):
+        if value is None or not isinstance(value, str):
+            return key, value
+
+        err_re = re.compile(r"ERR\|(\d{2})")
+        mac_re = re.compile(r"MAC,(\d+)\|(([0-9A-F]{2}[:-]){5}([0-9A-F]{2}))")
+        s32_re = re.compile(r"S32,(\d+),(\d+)\|(\d*)")
+        str_re = re.compile(r"STR,(\d+)\|(.*)")
+        typ_re = re.compile(r"TYP,(\w+)\|(\d+)")
+        if err_re.match(value):
+            value = int(err_re.search(value).groups()[0])
+        elif mac_re.match(value):
+            value = str(mac_re.search(value).groups()[1])
+        elif s32_re.match(value):
+            value = int(s32_re.search(value).groups()[2])
+        elif str_re.match(value):
+            value = str(str_re.search(value).groups()[1])
+        elif typ_re.match(value):
+            value = int(typ_re.search(value).groups()[1])
+        # Else: we are not interested in this value, just keep it as is
+
+        return key, value
+
+    @staticmethod
+    def _create_root_dict(path, my_dict=None):
+        if my_dict is None:
+            my_dict = {}
+        root = {}
+        elem = root
+        plist = path.strip("/").split("/")
+        k = len(plist) - 1
+        for i, j in enumerate(plist):
+            elem[j] = {}
+            if i == k:
+                elem[j] = my_dict
+            elem = elem.get(j)
+        return root
+
+    @staticmethod
+    def _clean_response_dict(response, path):
+        for i in path.strip("/").split("/"):
+            try:
+                i = int(i)
+                response = response[i]
+            except ValueError:
+                response = response.get(i)
+        return response
+
+    @staticmethod
+    def _xor(xml):
+        sz = bytearray.fromhex(
+            "0c384e4e62382d620e384e4e44382d300f382b382b0c5a6234384e304e4c372b10535a0c20432d171142444e58422c421157322a204036172056446262382b5f0c384e4e62382d620e385858082e232c0f382b382b0c5a62343830304e2e362b10545a0c3e432e1711384e625824371c1157324220402c17204c444e624c2e12"
+        )
+        buf = bytearray(xml)
+        for i in range(len(xml)):
+            ki = i & 0x7F
+            buf[i] = buf[i] ^ sz[ki]
+
+        return buf

pyasyncialarm/util.py

@@ -0,0 +1,31 @@
+"""Utils for iAlarm Home Assistant Integration."""
+
+from datetime import datetime
+from typing import Optional
+
+
+def parse_time(time_str: str) -> Optional[datetime]:
+    """Convert a time string to a datetime object."""
+    if "DTA,19" in time_str:
+        try:
+            return datetime.strptime(time_str.split("|")[1], "%Y.%m.%d.%H.%M.%S")
+        except (ValueError, IndexError):
+            return None
+    return None
+
+
+def decode_name(name_str: str) -> str:
+    """Decode a hexadecimal name."""
+    if "GBA" in name_str:
+        try:
+            return bytes.fromhex(name_str.split("|")[1]).decode(
+                "utf-8", errors="ignore"
+            )
+        except (ValueError, IndexError):
+            return name_str
+    return name_str
+
+
+def parse_bell(bell_value: str) -> bool:
+    """Convert the value 'Bell' to a boolean, checking 'BOL|T' for True."""
+    return bell_value == "BOL|T"

pyasyncialarm-2.3.0.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pyasyncialarm-2.3.0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: pyasyncialarm
+Version: 2.3.0
+Summary: A simple library to interface with iAlarm systems, built for use with Home-Assistant
+Author-email: Ludovico de Nittis <aasonykk+pyasyncialarm@gmail.com>
+License: MIT OR Apache-2.0
+Project-URL: Homepage, https://github.com/bigmoby/pyasyncialarm
+Project-URL: Source Code, https://github.com/bigmoby/pyasyncialarm
+Project-URL: Bug Reports, https://github.com/bigmoby/pyasyncialarm/issues
+Keywords: ialarm,antifurtocasa365,alarm
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dicttoxml2
+Requires-Dist: xmltodict
+
+# pyasyncialarm
+Python library to interface with [iAlarm systems](https://www.antifurtocasa365.it/).
+
+It has also been confirmed to work with the alarm systems brands Meian and Emooluxr.
+
+From the version 1.0 this library switched from webscraping the local configuration webpage to using the API that Android and iOS app use.
+Thanks to https://github.com/wildstray/meian-client for writing down the API specs.
+
+
+## Development
+
+Please run before creating a PR:
+
+`pre-commit run --all-files`
+
+and
+
+`pytest -vv tests/test_pyasyncialarm.py`

pyasyncialarm-2.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyasyncialarm/__init__.py,sha256=W70V-3XEFpdL94j0hDeInAh3y-MZB9etHL87gYtBOFY,97
+pyasyncialarm/const.py,sha256=LVnjcPq-csx4kyJASWJi0oy9GHJQdWpaRJurwYSNRok,3974
+pyasyncialarm/exception.py,sha256=vLnrzn2zLLdlr82GbcN-83F16R-ByDKlosK39EhJz0o,421
+pyasyncialarm/pyasyncialarm.py,sha256=tghEp9aVQhT2cZ18fSbtzcWqOpND1pvFbrmQehcFSeg,14424
+pyasyncialarm/util.py,sha256=9HE75XFZpfdkGxRdIAlm9W9tcmgU1uOe6KaiGEwHEyg,902
+pyasyncialarm-2.3.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyasyncialarm-2.3.0.dist-info/METADATA,sha256=FRcYPDQ06fDtdAsmxvHqSy4ERoncmfBcaCg_8zkdW-A,1491
+pyasyncialarm-2.3.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+pyasyncialarm-2.3.0.dist-info/top_level.txt,sha256=x_wGPr0ntLkb95oDpZ459gq6UXnVI2Ov4f2Uf3IFNdM,14
+pyasyncialarm-2.3.0.dist-info/RECORD,,

pyasyncialarm-2.3.0.dist-info/WHEEL

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

pyasyncialarm-2.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyasyncialarm