pyg90alarm 1.12.1__py3-none-any.whl → 1.14.0__py3-none-any.whl

pyg90alarm/host_info.py

@@ -21,26 +21,11 @@
 """
 Protocol entity for G90 alarm panel information.
 """
-
-from collections import namedtuple
+from __future__ import annotations
+from typing import Any, Dict
+from dataclasses import dataclass, asdict
 from enum import IntEnum
 
-INCOMING_FIELDS = [
-    'host_guid',
-    'product_name',
-    'wifi_protocol_version',
-    'cloud_protocol_version',
-    'mcu_hw_version',
-    'wifi_hw_version',
-    'gsm_status_data',
-    'wifi_status_data',
-    'reserved1',
-    'reserved2',
-    'band_frequency',
-    'gsm_signal_level',
-    'wifi_signal_level'
-]
-
 
 class G90HostInfoGsmStatus(IntEnum):
     """
@@ -62,26 +47,43 @@ class G90HostInfoWifiStatus(IntEnum):
     OPERATIONAL = 3
 
 
-class G90HostInfo(namedtuple('G90HostInfo', INCOMING_FIELDS)):
+@dataclass
+class G90HostInfo:  # pylint: disable=too-many-instance-attributes
     """
     Interprets data fields of GETHOSTINFO command.
     """
+    host_guid: str
+    product_name: str
+    wifi_protocol_version: str
+    cloud_protocol_version: str
+    mcu_hw_version: str
+    wifi_hw_version: str
+    gsm_status_data: int
+    wifi_status_data: int
+    reserved1: int
+    reserved2: int
+    band_frequency: str
+    gsm_signal_level: int
+    wifi_signal_level: int
+
     @property
-    def gsm_status(self):
+    def gsm_status(self) -> G90HostInfoGsmStatus:
         """
         Translates the GSM module status received from the device into
         corresponding enum.
-
-        :return: :class:`G90HostInfoGsmStatus`
         """
         return G90HostInfoGsmStatus(self.gsm_status_data)
 
     @property
-    def wifi_status(self):
+    def wifi_status(self) -> G90HostInfoWifiStatus:
         """
         Translates the Wifi module status received from the device into
         corresponding enum.
-
-        :return: :class:`G90HostInfoWifiStatus`
         """
         return G90HostInfoWifiStatus(self.wifi_status_data)
+
+    def _asdict(self) -> Dict[str, Any]:
+        """
+        Returns the host information as dictionary.
+        """
+        return asdict(self)

pyg90alarm/host_status.py

@@ -21,19 +21,32 @@
 """
 Protocol entity for G90 alarm panel status.
 """
+from __future__ import annotations
+from typing import Any, Dict
+from dataclasses import dataclass, asdict
+from .const import G90ArmDisarmTypes
 
-from collections import namedtuple
 
-INCOMING_FIELDS = [
-    'host_status',
-    'host_phone_number',
-    'product_name',
-    'mcu_hw_version',
-    'wifi_hw_version',
-]
-
-
-class G90HostStatus(namedtuple('G90HostStatus', INCOMING_FIELDS)):
+@dataclass
+class G90HostStatus:
     """
-    tbd
+    Interprets data fields of GETHOSTSTATUS command.
     """
+    host_status_data: int
+    host_phone_number: str
+    product_name: str
+    mcu_hw_version: str
+    wifi_hw_version: str
+
+    @property
+    def host_status(self) -> G90ArmDisarmTypes:
+        """
+        Translates host status data to G90ArmDisarmTypes.
+        """
+        return G90ArmDisarmTypes(self.host_status_data)
+
+    def _asdict(self) -> Dict[str, Any]:
+        """
+        Returns the host information as dictionary.
+        """
+        return asdict(self)

pyg90alarm/paginated_cmd.py

@@ -21,70 +21,75 @@
 """
 Implements paginated command for G90 alarm panel protocol.
 """
-
+from __future__ import annotations
 import logging
-from collections import namedtuple
-from .base_cmd import G90BaseCommand
+from typing import Any, cast
+from dataclasses import dataclass
+from .base_cmd import G90BaseCommand, G90BaseCommandData
 from .exceptions import G90Error
+from .const import G90Commands
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class G90PaginationFields(namedtuple('G90PaginationFields',
-                                     ['total', 'start', 'count'])):
+@dataclass
+class G90PaginationFields:
     """
-    tbd
+    Represents structure of the pagination fields used by alarm panel.
 
     :meta private:
     """
+    total: int
+    start: int
+    nelems: int
 
 
 class G90PaginatedCommand(G90BaseCommand):
     """
-    tbd
+    Implements paginated command for alarm panel protocol.
     """
-    def __init__(self, host, port, code, start, end, **kwargs):
-        """
-        tbd
-        """
+    def __init__(
+        self, host: str, port: int, code: G90Commands, start: int, end: int,
+        **kwargs: Any
+    ) -> None:
         # pylint: disable=too-many-arguments
         self._start = start
         self._end = end
-        self._expected_count = end - start + 1
-        self._count = 0
+        self._expected_nelems = end - start + 1
+        self._nelems = 0
         self._total = 0
         super().__init__(host, port, code, [self._start, self._end],
                          **kwargs)
 
     @property
-    def total(self):
+    def total(self) -> int:
         """
-        tbd
+        Total number of records available.
         """
         return self._total
 
     @property
-    def start(self):
+    def start(self) -> int:
         """
-        tbd
+        Index of the first record in the response.
         """
         return self._start
 
     @property
-    def count(self):
+    def count(self) -> int:
         """
-        tbd
+        Number of records in the response.
         """
-        return self._count
+        return self._nelems
 
-    def _parse(self, data):
+    def _parse(self, data: str) -> None:
         """
-        tbd
+        Parses the response from the alarm panel.
         """
         super()._parse(data)
-        data = self._resp.data or []
+        resp_data: G90BaseCommandData = self._resp.data or []
         try:
-            page_data = data.pop(0)
+            page_data = resp_data.pop(0)
             page_info = G90PaginationFields(*page_data)
         except TypeError as exc:
             raise G90Error(f'Wrong pagination data {page_data} - {str(exc)}'
@@ -95,25 +100,33 @@ class G90PaginatedCommand(G90BaseCommand):
 
         self._total = page_info.total
         self._start = page_info.start
-        self._count = page_info.count
+        self._nelems = page_info.nelems
 
         errors = []
-        if self._count != len(data):
-            qualifier = "Truncated" if self._count > len(data) else "Extra"
+        if self._nelems != len(resp_data):
+            qualifier = (
+                "Truncated" if self._nelems > len(resp_data) else "Extra"
+            )
             errors.append(
                 f'{qualifier} data provided in paginated response -'
-                f' expected {self._count} entities as per response,'
-                f' received {len(data)}')
+                f' expected {self._nelems} entities as per response,'
+                f' received {len(resp_data)}')
 
-        if self._expected_count < len(data):
+        if self._expected_nelems < len(resp_data):
             errors.append(
                 f'Extra data provided in paginated response -'
-                f' expected {self._expected_count} entities as per request,'
-                f' received {len(data)}')
+                f' expected {self._expected_nelems} entities as per request,'
+                f' received {len(resp_data)}')
 
         if errors:
             raise G90Error('. '.join(errors))
 
         _LOGGER.debug('Paginated command response: '
                       'total records %s, start record %s, record count %s',
-                      page_info.total, page_info.start, page_info.count)
+                      page_info.total, page_info.start, page_info.nelems)
+
+    async def process(self) -> G90PaginatedCommand:
+        """
+        Initiates the command processing.
+        """
+        return cast(G90PaginatedCommand, await super().process())

pyg90alarm/paginated_result.py

@@ -24,21 +24,24 @@ to work with results of paginated commands.
 """
 
 import logging
-from collections import namedtuple
+from typing import Any, Optional, AsyncGenerator, Iterable, cast
+from dataclasses import dataclass
 from .paginated_cmd import G90PaginatedCommand
 from .const import (
+    G90Commands,
     CMD_PAGE_SIZE,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class G90PaginatedResponse(
-    namedtuple('G90PaginatedResponse', ['proto_idx', 'data'])
-):
+@dataclass
+class G90PaginatedResponse:
     """
     Response yielded from the :meth:`.G90PaginatedResult.process` method
     """
+    proto_idx: int
+    data: str
 
 
 class G90PaginatedResult:
@@ -46,7 +49,10 @@ class G90PaginatedResult:
     Processes paginated response from G90 corresponding panel commands.
     """
     # pylint: disable=too-few-public-methods
-    def __init__(self, host, port, code, start=1, end=None, **kwargs):
+    def __init__(
+        self, host: str, port: int, code: G90Commands, start: int = 1,
+        end: Optional[int] = None, **kwargs: Any
+    ):
         # pylint: disable=too-many-arguments
         self._host = host
         self._port = port
@@ -55,7 +61,7 @@ class G90PaginatedResult:
         self._end = end
         self._kwargs = kwargs
 
-    async def process(self):
+    async def process(self) -> AsyncGenerator[G90PaginatedResponse, None]:
         """
         Process paginated response yielding :class:`.G90PaginatedResponse`
         instance for each element.
@@ -100,7 +106,7 @@ class G90PaginatedResult:
                           cmd.count, cmd.total, self._end)
 
             # Produce the resulting records for the consumer
-            for idx, data in enumerate(cmd.result):
+            for idx, data in enumerate(cast(Iterable[str], cmd.result)):
                 # Protocol uses one-based indexes, `start` implies that so no
                 # further additions to resulting value is needed.
                 # Note the index provided here is running one across multiple

pyg90alarm/targeted_discovery.py

@@ -21,58 +21,85 @@
 """
 Discovers G90 alarm panel devices with specific ID.
 """
-
+from __future__ import annotations
 import logging
-from collections import namedtuple
-from .discovery import G90Discovery
+from typing import Tuple, Any, Optional, Dict, List
+from dataclasses import dataclass, asdict
+import asyncio
+from asyncio.transports import BaseTransport
+from .base_cmd import G90BaseCommand
+from .const import G90Commands
 from .exceptions import G90Error
 
 _LOGGER = logging.getLogger(__name__)
 
-INCOMING_FIELDS = [
-    'message',
-    'product_name',
-    'wifi_protocol_version',
-    'cloud_protocol_version',
-    'mcu_hw_version',
-    'fw_version',
-    'gsm_status',
-    'wifi_status',
-    'server_status',
-    'reserved1',
-    'reserved2',
-    'gsm_signal_level',
-    'wifi_signal_level'
-]
-
-
-class G90TargetedDiscoveryInfo(namedtuple('G90TargetedDiscoveryInfo',
-                                          INCOMING_FIELDS)):
-    """
-    tbd
 
-    :meta private:
+@dataclass
+# pylint: disable=too-many-instance-attributes
+class G90TargetedDiscoveryInfo:
     """
+    Wire representation of the information about discovered device.
+    """
+    message: str
+    product_name: str
+    wifi_protocol_version: str
+    cloud_protocol_version: str
+    mcu_hw_version: str
+    fw_version: str
+    gsm_status: str
+    wifi_status: str
+    server_status: str
+    reserved1: str
+    reserved2: str
+    gsm_signal_level: str
+    wifi_signal_level: str
+
+    def _asdict(self) -> Dict[str, Any]:
+        """
+        Returns the information about discovered device as dictionary.
+        """
+        return asdict(self)
 
 
-class G90TargetedDiscovery(G90Discovery):
+@dataclass
+class G90DiscoveredDeviceTargeted(G90TargetedDiscoveryInfo):
     """
-    tbd
+    Discovered device with specific ID.
     """
+    host: str
+    port: int
+    guid: str
+
 
+class G90TargetedDiscovery(G90BaseCommand):
+    """
+    Discovers alarm panel devices with specific ID.
+    """
     # pylint: disable=too-few-public-methods
-    def __init__(self, device_id, **kwargs):
+    def __init__(self, device_id: str, **kwargs: Any):
+        super().__init__(
+            # No actual command will be processed by base class, `NONE` is used
+            # for proper typing only
+            code=G90Commands.NONE, **kwargs
+        )
+        self._device_id = device_id
+        self._discovered_devices: List[G90DiscoveredDeviceTargeted] = []
+
+    def connection_made(self, transport: BaseTransport) -> None:
         """
-        tbd
+        Invoked when connection is established.
+        """
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        """
+        Invoked when connection is lost.
         """
-        super().__init__(**kwargs)
-        self._device_id = device_id
 
     # Implementation of datagram protocol,
     # https://docs.python.org/3/library/asyncio-protocol.html#datagram-protocols
-    def datagram_received(self, data, addr):
+    def datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None:
         """
-        tbd
+        Invoked when datagram is received.
         """
         try:
             _LOGGER.debug('Received from %s:%s: %s', addr[0], addr[1], data)
@@ -82,17 +109,49 @@ class G90TargetedDiscovery(G90Discovery):
             host_info = G90TargetedDiscoveryInfo(*decoded[:-1].split(','))
             if host_info.message != 'IWTAC_PROBE_DEVICE_ACK':
                 raise G90Error('Invalid discovery response')
-            res = {'guid': self._device_id,
-                   'host': addr[0],
-                   'port': addr[1]}
-            res.update(host_info._asdict())
+            res = G90DiscoveredDeviceTargeted(
+                host=addr[0],
+                port=addr[1],
+                guid=self._device_id,
+                **host_info._asdict()
+            )
             _LOGGER.debug('Discovered device: %s', res)
             self.add_device(res)
         except Exception as exc:  # pylint: disable=broad-except
             _LOGGER.warning('Got exception, ignoring: %s', exc)
 
-    def to_wire(self):
+    def error_received(self, exc: Exception) -> None:
+        """
+        Invoked when error is received.
+        """
+
+    def to_wire(self) -> bytes:
         """
-        tbd
+        Converts the command to wire representation.
         """
         return bytes(f'IWTAC_PROBE_DEVICE,{self._device_id}\0', 'ascii')
+
+    async def process(self) -> G90TargetedDiscovery:
+        """
+        Initiates the device discovery process.
+        """
+        _LOGGER.debug('Attempting device discovery...')
+        transport, _ = await self._create_connection()
+        transport.sendto(self.to_wire())
+        await asyncio.sleep(self._timeout)
+        transport.close()
+        _LOGGER.debug('Discovered %s devices', len(self.devices))
+        return self
+
+    @property
+    def devices(self) -> List[G90DiscoveredDeviceTargeted]:
+        """
+        The list of discovered devices.
+        """
+        return self._discovered_devices
+
+    def add_device(self, value: G90DiscoveredDeviceTargeted) -> None:
+        """
+        Adds discovered device to the list.
+        """
+        self._discovered_devices.append(value)

pyg90alarm/user_data_crc.py

@@ -22,20 +22,25 @@
 Protocol entity for G90 alarm panel that provides checksums of different
 on-device databases.
 """
+from __future__ import annotations
+from typing import Any, Dict
+from dataclasses import dataclass, asdict
 
-from collections import namedtuple
 
-INCOMING_FIELDS = [
-    'sensor_list',
-    'device_list',
-    'history_list',
-    'scene_list',
-    'ifttt_list',
-    'fingerprint_list',
-]
-
-
-class G90UserDataCRC(namedtuple('G90UserDataCRC', INCOMING_FIELDS)):
+@dataclass
+class G90UserDataCRC:
     """
-    tbd
+    Represents structure of GETUSERDATACRC command response.
     """
+    sensor_list: str
+    device_list: str
+    history_list: str
+    scene_list: str
+    ifttt_list: str
+    fingerprint_list: str
+
+    def _asdict(self) -> Dict[str, Any]:
+        """
+        Returns the host information as dictionary.
+        """
+        return asdict(self)

{pyg90alarm-1.12.1.dist-info → pyg90alarm-1.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyg90alarm
-Version: 1.12.1
+Version: 1.14.0
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -15,12 +15,13 @@ Classifier: Topic :: Home Automation
 Classifier: Topic :: System :: Hardware
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7, <4
+Requires-Python: >=3.8, <4
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: dev

pyg90alarm-1.14.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+pyg90alarm/__init__.py,sha256=5AITRm5jZSzuQaL7PS8fZZMZb4-IuGRhSqyAdfTt0Cs,2236
+pyg90alarm/alarm.py,sha256=N2TTK1F1ZVmj_fCxrx1zNvdMO6HsPOz4yIVcoWnyd2I,31777
+pyg90alarm/base_cmd.py,sha256=wu2v_RKpcPHxUW4HBDLWcUFMzPsGooY4o2Rc0LgcanU,9754
+pyg90alarm/callback.py,sha256=3JsD_JChmZD24OyjaCP-PxxuBDBX7myGYhkM4RN7bk4,3742
+pyg90alarm/config.py,sha256=2YtIgdT7clQXmYvkdn_fhIdS05CY8E1Yc90R8_tAmRI,1961
+pyg90alarm/const.py,sha256=4eJyEZpUE5XZkNL1sePKnuPloIvcjKIAJJ4g2e1cXVA,6054
+pyg90alarm/device_notifications.py,sha256=I5K8IsyYTe0XDJT8XiQoC8a2xY1XLjaGx4QFrEsaixg,11135
+pyg90alarm/discovery.py,sha256=fwyBHDCKGej06OwhpbVCHYTRU9WWkeYysAFgv3FiwqI,3575
+pyg90alarm/exceptions.py,sha256=eiOcRe7D18EIPyPFDNU9DdFgbnkwPmkiLl8lGPOhBNw,1475
+pyg90alarm/history.py,sha256=st9RWfrBbn4LLjfz3MguocPSnaTIATzIiBq2hLNeVTY,7380
+pyg90alarm/host_info.py,sha256=4lFIaFEpYd3EvgNrDJmKijTrzX9i29nFISLLlXGnkmE,2759
+pyg90alarm/host_status.py,sha256=4XhuilBzB8XsXkpeWj3PAVpmDPcTnBBOYunO21Flabo,1862
+pyg90alarm/paginated_cmd.py,sha256=vJ8slMS7aNLpkAxnIe25EHstusYy1bYTl1j306ps-MQ,4439
+pyg90alarm/paginated_result.py,sha256=Zs_yB9UW6VlHRBPIzOwHy8ZJ0FqCUPMB-rmfPG2BdnU,5447
+pyg90alarm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyg90alarm/targeted_discovery.py,sha256=zD-oW8u75H39sBanKX_Cjwz3_z_n__TC20doSctmy-g,5336
+pyg90alarm/user_data_crc.py,sha256=JQBOPY3RlOgVtvR55R-rM8OuKjYW-BPXQ0W4pi6CEH0,1689
+pyg90alarm/definitions/__init__.py,sha256=s0NZnkW_gMH718DJbgez28z9WA231CyszUf1O_ojUiI,68
+pyg90alarm/definitions/sensors.py,sha256=rKOu21ZpI44xk6aMh_vBjniFqnsNTc1CKwAvnv4PYLQ,19904
+pyg90alarm/entities/__init__.py,sha256=hHb6AOiC4Tz--rOWiiICMdLaZDs1Tf_xpWk_HeS_gO4,66
+pyg90alarm/entities/device.py,sha256=f_LHvKCAqTEebZ4mrRh3CpPUI7o-OvpvOfyTRCbftJs,2818
+pyg90alarm/entities/sensor.py,sha256=qg08Myz_P4aTd29R37Js0feSfuJ-u2U6F-6FZiS76D0,15124
+pyg90alarm-1.14.0.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
+pyg90alarm-1.14.0.dist-info/METADATA,sha256=Km8Q2Kl5fdxdypLxpA201_A8kfujIpzu5hiSozidmR4,7663
+pyg90alarm-1.14.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+pyg90alarm-1.14.0.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
+pyg90alarm-1.14.0.dist-info/RECORD,,

{pyg90alarm-1.12.1.dist-info → pyg90alarm-1.14.0.dist-info}/WHEEL

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

pyg90alarm-1.12.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-pyg90alarm/__init__.py,sha256=zidYApReScSFZCpC9Tk7pdsBNPMql6XiUtt-O7l3D5M,1381
-pyg90alarm/alarm.py,sha256=aEKmWt_iofBHo2bI59uuCcqBDHeppj2B32_wcBVWBgE,30023
-pyg90alarm/base_cmd.py,sha256=rjpjIzEgtI5mUvmurBasrt9psYKdbIEsivnx8QboivY,8561
-pyg90alarm/callback.py,sha256=zg698TCjjYhjAMk770J9CZp8-dDbX0Zj5wtoC6axq6w,4033
-pyg90alarm/config.py,sha256=FiYjiz_WrDH2OEqHyUJXZDDK7v1fLAUpZcQ3JRMmmX0,1974
-pyg90alarm/const.py,sha256=XP_x5w6quiKQceOJDpExXI86L5KbQLdTed4lbjlNth0,5760
-pyg90alarm/device_notifications.py,sha256=JLdOIIwyoxQdqvIjuLj6_5Rz_W6slYeM8HBPzPIa1ew,10628
-pyg90alarm/discovery.py,sha256=sPk2mRhc0IgpOIlC9kRlKCnlAfdXsT7TyWfHAc1bfqQ,3077
-pyg90alarm/exceptions.py,sha256=eiOcRe7D18EIPyPFDNU9DdFgbnkwPmkiLl8lGPOhBNw,1475
-pyg90alarm/history.py,sha256=Ln3-v8hvagIXTmj_2iURE3oOsVLeQb8OMczUy-SKSRs,7039
-pyg90alarm/host_info.py,sha256=fGGI2ZH6GVD0WhYT72rIELTbiIAmmPiT31eZkyVugwY,2571
-pyg90alarm/host_status.py,sha256=PEPgpkfGNkUzKUgRpfPKldz5qq3_9lqBwX86Ld613vk,1406
-pyg90alarm/paginated_cmd.py,sha256=7pXLAgFQHheByBpwRV-I1yEdZnm8hk6j2OMPZ_Wn-vE,3768
-pyg90alarm/paginated_result.py,sha256=xweFfPLn1a2yYm5h0AxGoDCyDIoy0JkUC_tI80vsrLc,5246
-pyg90alarm/targeted_discovery.py,sha256=DPxNvs8qJfyIOq6KLBYBpqkHPCpHbMW70_gfNyvNAoY,3221
-pyg90alarm/user_data_crc.py,sha256=RsQlbuXC4baD88hX4y0XdysmxEMtQkqkNVX_FhTLSmw,1467
-pyg90alarm/definitions/__init__.py,sha256=s0NZnkW_gMH718DJbgez28z9WA231CyszUf1O_ojUiI,68
-pyg90alarm/definitions/sensors.py,sha256=2Liap0stTT5qNmvsbP_7UscA21IYXQcSAKQLLm7YfHQ,19921
-pyg90alarm/entities/__init__.py,sha256=hHb6AOiC4Tz--rOWiiICMdLaZDs1Tf_xpWk_HeS_gO4,66
-pyg90alarm/entities/device.py,sha256=QbsQyIq2wFLjIH389zyD3d0CyME_rpG_ciD3srAdqXQ,2772
-pyg90alarm/entities/sensor.py,sha256=AkVj_qrK35K5SwSlAHXU9UXdBKVaJzV4TBcoeZUevn4,13942
-pyg90alarm-1.12.1.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
-pyg90alarm-1.12.1.dist-info/METADATA,sha256=AECT6-eg76TO0qbW2VXZQARBlzpYjtnxOL-BuM-R_3E,7611
-pyg90alarm-1.12.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-pyg90alarm-1.12.1.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
-pyg90alarm-1.12.1.dist-info/RECORD,,