pypck 0.9.7__py3-none-any.whl → 0.9.9__py3-none-any.whl

pypck/device.py

@@ -50,8 +50,6 @@ class DeviceConnection:
         self._serials_known = asyncio.Event()
 
         self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
-        self.last_requested_var_without_type_in_response = lcn_defs.Var.UNKNOWN
-        self.last_var_lock = asyncio.Lock()
 
         # List of queued acknowledge codes from the LCN modules.
         self.acknowledges: asyncio.Queue[lcn_defs.AcknowledgeErrorCode] = (
@@ -60,6 +58,7 @@ class DeviceConnection:
 
         # StatusRequester
         self.status_requester = StatusRequester(self)
+        self.request_lock = asyncio.Lock()
 
         if self.addr.is_group:
             self.wants_ack = False  # groups do not send acks
@@ -773,29 +772,9 @@ class DeviceConnection:
             await self.on_ack(inp.code)
             return None
 
-        # handle typeless variable responses
-        if isinstance(inp, inputs.ModStatusVar):
-            inp = self.preprocess_modstatusvar(inp)
-
         for input_callback in self.input_callbacks:
             input_callback(inp)
 
-    def preprocess_modstatusvar(self, inp: inputs.ModStatusVar) -> inputs.Input:
-        """Fill typeless response with last requested variable type."""
-        if inp.orig_var == lcn_defs.Var.UNKNOWN:
-            # Response without type (%Msssaaa.wwwww)
-            inp.var = self.last_requested_var_without_type_in_response
-
-            self.last_requested_var_without_type_in_response = lcn_defs.Var.UNKNOWN
-
-            if self.last_var_lock.locked():
-                self.last_var_lock.release()
-        else:
-            # Response with variable type (%Msssaaa.Avvvwww)
-            inp.var = inp.orig_var
-
-        return inp
-
     async def dump_details(self) -> dict[str, Any]:
         """Dump detailed information about this module."""
         is_local_segment = self.addr.seg_id in (0, self.conn.local_seg_id)
@@ -816,11 +795,15 @@ class DeviceConnection:
             "groups": {
                 "static": sorted(
                     addr.addr_id
-                    for addr in await self.request_group_memberships(dynamic=False)
+                    for addr in (
+                        await self.request_group_memberships(dynamic=False) or set()
+                    )
                 ),
                 "dynamic": sorted(
                     addr.addr_id
-                    for addr in await self.request_group_memberships(dynamic=True)
+                    for addr in (
+                        await self.request_group_memberships(dynamic=True) or set()
+                    )
                 ),
             },
         }
@@ -844,15 +827,13 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusOutput,
             request_pck=PckGenerator.request_output_status(output_id=output_port.value),
             max_age=max_age,
             output_id=output_port.value,
         )
 
-        return cast(inputs.ModStatusOutput, result)
-
     async def request_status_relays(
         self, max_age: int = 0
     ) -> inputs.ModStatusRelays | None:
@@ -861,14 +842,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusRelays,
             request_pck=PckGenerator.request_relays_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusRelays, result)
-
     async def request_status_motor_position(
         self,
         motor: lcn_defs.MotorPort,
@@ -894,15 +873,13 @@ class DeviceConnection:
             _LOGGER.debug("Only BS4 mode is supported for motor position requests.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusMotorPositionBS4,
             request_pck=PckGenerator.request_motor_position_status(motor.value // 2),
             max_age=max_age,
             motor=motor.value,
         )
 
-        return cast(inputs.ModStatusMotorPositionBS4, result)
-
     async def request_status_binary_sensors(
         self, max_age: int = 0
     ) -> inputs.ModStatusBinSensors | None:
@@ -911,14 +888,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusBinSensors,
             request_pck=PckGenerator.request_bin_sensors_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusBinSensors, result)
-
     async def request_status_variable(
         self,
         variable: lcn_defs.Var,
@@ -929,17 +904,17 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        # do not use buffered response for old modules
-        # (variable response is typeless)
-        if self.serials.software_serial < 0x170206:
-            if not lcn_defs.Var.has_type_in_response(
-                variable, self.serials.software_serial
-            ):
-                try:
-                    await asyncio.wait_for(self.last_var_lock.acquire(), timeout=3.0)
-                except asyncio.TimeoutError:
-                    pass
-                self.last_requested_var_without_type_in_response = variable
+        response_variable = variable
+
+        # for old modules the variable response is typeless
+        # - do not use concurrent requests
+        # - do not use buffered response
+        if has_typeless_response := not lcn_defs.Var.has_type_in_response(
+            variable, self.serials.software_serial
+        ):
+            await self.request_lock.acquire()
+            max_age = 0
+            response_variable = lcn_defs.Var.UNKNOWN
 
         result = await self.status_requester.request(
             response_type=inputs.ModStatusVar,
@@ -947,10 +922,19 @@ class DeviceConnection:
                 variable, self.serials.software_serial
             ),
             max_age=max_age,
-            var=variable,
+            var=response_variable,
         )
 
-        return cast(inputs.ModStatusVar, result)
+        # for old modules (typeless response) we need to set the original variable
+        # - call input_callbacks with the original variable type
+        if result is not None and has_typeless_response:
+            result.var = variable
+            for input_callback in self.input_callbacks:
+                input_callback(result)
+
+        if self.request_lock.locked():
+            self.request_lock.release()
+        return result
 
     async def request_status_led_and_logic_ops(
         self, max_age: int = 0
@@ -960,14 +944,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusLedsAndLogicOps,
             request_pck=PckGenerator.request_leds_and_logic_ops(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusLedsAndLogicOps, result)
-
     async def request_status_locked_keys(
         self, max_age: int = 0
     ) -> inputs.ModStatusKeyLocks | None:
@@ -976,14 +958,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusKeyLocks,
             request_pck=PckGenerator.request_key_lock_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusKeyLocks, result)
-
     # Request module properties
 
     async def request_serials(self, max_age: int = 0) -> Serials:
@@ -992,23 +972,20 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
 
-        result = cast(
-            inputs.ModSn | None,
-            await self.status_requester.request(
-                response_type=inputs.ModSn,
-                request_pck=PckGenerator.request_serial(),
-                max_age=max_age,
-            ),
+        result = await self.status_requester.request(
+            response_type=inputs.ModSn,
+            request_pck=PckGenerator.request_serial(),
+            max_age=max_age,
         )
 
-        if result is None:
-            return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
-        return Serials(
-            result.hardware_serial,
-            result.manu,
-            result.software_serial,
-            result.hardware_type,
-        )
+        if isinstance(result, inputs.ModSn):
+            return Serials(
+                result.hardware_serial,
+                result.manu,
+                result.software_serial,
+                result.hardware_type,
+            )
+        return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
 
     async def request_name(self, max_age: int = 0) -> str | None:
         """Request module name."""
@@ -1016,7 +993,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_name(block_id),
@@ -1024,8 +1001,8 @@ class DeviceConnection:
                 command="N",
                 block_id=block_id,
             )
-            for block_id in [0, 1]
-        ]
+            for block_id in (0, 1)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
@@ -1040,7 +1017,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_comment(block_id),
@@ -1048,15 +1025,15 @@ class DeviceConnection:
                 command="K",
                 block_id=block_id,
             )
-            for block_id in [0, 1, 2]
-        ]
+            for block_id in (0, 1, 2)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
             return None
         results = cast(list[inputs.ModNameComment], coro_results)
-        name = "".join([result.text for result in results if result])
-        return name
+        comment = "".join([result.text for result in results if result])
+        return comment
 
     async def request_oem_text(self, max_age: int = 0) -> str | None:
         """Request module name."""
@@ -1064,7 +1041,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_oem_text(block_id),
@@ -1072,19 +1049,19 @@ class DeviceConnection:
                 command="O",
                 block_id=block_id,
             )
-            for block_id in [0, 1, 2, 3]
-        ]
+            for block_id in (0, 1, 2, 3)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
             return None
         results = cast(list[inputs.ModNameComment], coro_results)
-        name = "".join([result.text for result in results if result])
-        return name
+        oem_text = "".join([result.text for result in results if result])
+        return oem_text
 
     async def request_group_memberships(
         self, dynamic: bool = False, max_age: int = 0
-    ) -> set[LcnAddr]:
+    ) -> set[LcnAddr] | None:
         """Request module static/dynamic group memberships."""
         if self.addr.is_group:
             _LOGGER.info("Status requests are not supported for groups.")
@@ -1100,5 +1077,6 @@ class DeviceConnection:
             max_age=max_age,
             dynamic=dynamic,
         )
-
-        return set(cast(inputs.ModStatusGroups, result).groups)
+        if result is not None:
+            return set(result.groups)
+        return None

pypck/inputs.py

@@ -26,6 +26,7 @@ class Input:
 
     def __init__(self) -> None:
         """Construct Input object."""
+        self.pck = ""
 
     @staticmethod
     def try_parse(data: str) -> list[Input] | None:
@@ -1368,9 +1369,11 @@ class InputParser:
         :rtype:     List with instances of :class:`~pypck.input.Input`
         """
         for parser in InputParser.parsers:
-            ret: list[Input] | None = parser.try_parse(data)
-            if ret is not None:
-                return ret
+            returns: list[Input] | None = parser.try_parse(data)
+            if returns is not None:
+                for ret in returns:
+                    ret.pck = data
+                return returns
 
         # We must never get to this point since the Unknown parser matches
         # everything.

pypck/pck_commands.py

@@ -880,20 +880,20 @@ class PckGenerator:
         if software_serial >= 0x170206:
             var_id = lcn_defs.Var.to_var_id(var)
             if var_id != -1:
-                return f"MWT{var_id + 1:03d}"
+                return f"MWT{var_id + 1}"
 
             set_point_id = lcn_defs.Var.to_set_point_id(var)
             if set_point_id != -1:
-                return f"MWS{set_point_id + 1:03d}"
+                return f"MWS{set_point_id + 1}"
 
             thrs_register_id = lcn_defs.Var.to_thrs_register_id(var)
             if thrs_register_id != -1:
                 # Whole register
-                return f"SE{thrs_register_id + 1:03d}"
+                return f"SE{thrs_register_id + 1}"
 
             s0_id = lcn_defs.Var.to_s0_id(var)
             if s0_id != -1:
-                return f"MWC{s0_id + 1:03d}"
+                return f"MWC{s0_id + 1}"
         else:
             if var == lcn_defs.Var.VAR1ORTVAR:
                 pck = "MWV"

pypck/status_requester.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
 
 from pypck import inputs
 
@@ -14,147 +14,142 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+ResponseT = TypeVar("ResponseT", bound=inputs.Input)
+
 
 @dataclass(unsafe_hash=True)
-class StatusRequest:
+class StatusRequest(Generic[ResponseT]):
     """Data class for status requests."""
 
-    type: type[inputs.Input]  # Type of the input expected as response
+    type: type[ResponseT]  # Type of the input expected as response
     parameters: frozenset[tuple[str, Any]]  # {(parameter_name, parameter_value)}
     timestamp: float = field(
         compare=False
     )  # timestamp the response was received; -1=no timestamp
-    response: asyncio.Future[inputs.Input] = field(
+    response: asyncio.Future[ResponseT] = field(
         compare=False
-    )  # Future to hold the response input object
+    )  # the response input object
 
 
 class StatusRequester:
     """Handling of status requests."""
 
+    current_request: StatusRequest[inputs.Input] | None
+
     def __init__(
         self,
         device_connection: DeviceConnection,
     ) -> None:
         """Initialize the context."""
         self.device_connection = device_connection
-        self.last_requests: set[StatusRequest] = set()
+        self.current_request = None
+        self.request_cache: set[StatusRequest[inputs.Input]] = set()
+        self.max_response_age = self.device_connection.conn.settings["MAX_RESPONSE_AGE"]
+        self.request_lock = asyncio.Lock()
+
         self.unregister_inputs = self.device_connection.register_for_inputs(
             self.input_callback
         )
-        self.max_response_age = self.device_connection.conn.settings["MAX_RESPONSE_AGE"]
-        # asyncio.get_running_loop().create_task(self.prune_loop())
-
-    async def prune_loop(self) -> None:
-        """Periodically prune old status requests."""
-        while True:
-            await asyncio.sleep(self.max_response_age)
-            self.prune_status_requests()
-
-    def prune_status_requests(self) -> None:
-        """Prune old status requests."""
-        entries_to_remove = {
-            request
-            for request in self.last_requests
-            if asyncio.get_running_loop().time() - request.timestamp
-            > self.max_response_age
-        }
-        for entry in entries_to_remove:
-            entry.response.cancel()
-        self.last_requests.difference_update(entries_to_remove)
 
     def get_status_requests(
         self,
-        request_type: type[inputs.Input],
+        request_type: type[ResponseT],
         parameters: frozenset[tuple[str, Any]] | None = None,
         max_age: int = 0,
-    ) -> list[StatusRequest]:
+    ) -> list[StatusRequest[ResponseT]]:
         """Get the status requests for the given type and parameters."""
         if parameters is None:
             parameters = frozenset()
-        loop = asyncio.get_running_loop()
         results = [
             request
-            for request in self.last_requests
+            for request in self.request_cache
             if request.type == request_type
             and parameters.issubset(request.parameters)
             and (
                 (request.timestamp == -1)
                 or (max_age == -1)
-                or (loop.time() - request.timestamp < max_age)
+                or (asyncio.get_running_loop().time() - request.timestamp < max_age)
             )
         ]
         results.sort(key=lambda request: request.timestamp, reverse=True)
-        return results
+        return cast(list[StatusRequest[ResponseT]], results)
 
     def input_callback(self, inp: inputs.Input) -> None:
         """Handle incoming inputs and set the result for the corresponding requests."""
-        requests = [
-            request
-            for request in self.get_status_requests(type(inp))
+        # Update current request (if it exists)
+        if (
+            self.current_request is not None
+            and not self.current_request.response.done()
+        ):
+            if isinstance(inp, self.current_request.type) and all(
+                getattr(inp, parameter_name) == parameter_value
+                for parameter_name, parameter_value in self.current_request.parameters
+            ):
+                self.current_request.timestamp = asyncio.get_running_loop().time()
+                self.current_request.response.set_result(inp)
+
+        # Update cached requests
+        for request in self.get_status_requests(type(inp)):
             if all(
                 getattr(inp, parameter_name) == parameter_value
                 for parameter_name, parameter_value in request.parameters
-            )
-        ]
-        for request in requests:
-            if request.response.done() or request.response.cancelled():
-                continue
-            request.timestamp = asyncio.get_running_loop().time()
-            request.response.set_result(inp)
+            ):
+                request.timestamp = asyncio.get_running_loop().time()
+                request.response = asyncio.get_running_loop().create_future()
+                request.response.set_result(inp)
 
     async def request(
         self,
-        response_type: type[inputs.Input],
+        response_type: type[ResponseT],
         request_pck: str,
         request_acknowledge: bool = False,
         max_age: int = 0,  # -1: no age limit / infinite age
         **request_kwargs: Any,
-    ) -> inputs.Input | None:
+    ) -> ResponseT | None:
         """Execute a status request and wait for the response."""
-        parameters = frozenset(request_kwargs.items())
-
-        # check if we already have a received response for the current request
-        if requests := self.get_status_requests(response_type, parameters, max_age):
-            try:
-                async with asyncio.timeout(
-                    self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
-                ):
-                    return await requests[0].response
-            except asyncio.TimeoutError:
-                return None
-            except asyncio.CancelledError:
-                return None
-
-        # no stored request or forced request: set up a new request
-        request = StatusRequest(
-            response_type,
-            frozenset(request_kwargs.items()),
-            -1,
-            asyncio.get_running_loop().create_future(),
-        )
+        async with self.request_lock:
+            # check for matching request in cache
+            if requests := self.get_status_requests(
+                response_type,
+                frozenset(request_kwargs.items()),
+                max_age,
+            ):
+                _LOGGER.debug(
+                    "from %s: %s (cached)",
+                    self.device_connection.conn.connection_id,
+                    requests[0].response.result().pck,
+                )
+                return requests[0].response.result()
+
+            # no matching request in cache
+            self.current_request = StatusRequest(
+                response_type,
+                frozenset(request_kwargs.items()),
+                -1,
+                asyncio.get_running_loop().create_future(),
+            )
 
-        self.last_requests.discard(request)
-        self.last_requests.add(request)
-        result = None
-        # send the request up to NUM_TRIES and wait for response future completion
-        for _ in range(self.device_connection.conn.settings["NUM_TRIES"]):
-            await self.device_connection.send_command(request_acknowledge, request_pck)
-
-            try:
-                async with asyncio.timeout(
-                    self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
-                ):
-                    # Need to shield the future. Otherwise it would get cancelled.
-                    result = await asyncio.shield(request.response)
+            result = None
+            # send the request up to NUM_TRIES and wait for response future completion
+            for _ in range(self.device_connection.conn.settings["NUM_TRIES"]):
+                await self.device_connection.send_command(
+                    request_acknowledge, request_pck
+                )
+
+                try:
+                    async with asyncio.timeout(
+                        self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
+                    ):
+                        # Need to shield the future. Otherwise it would get cancelled.
+                        result = await asyncio.shield(self.current_request.response)
+                        break
+                except asyncio.TimeoutError:
+                    continue
+                except asyncio.CancelledError:
                     break
-            except asyncio.TimeoutError:
-                continue
-            except asyncio.CancelledError:
-                break
-
-        # if we got no results, remove the request from the set
-        if result is None:
-            request.response.cancel()
-            self.last_requests.discard(request)
-        return result
+
+            if result is not None:  # add request to cache
+                self.request_cache.discard(self.current_request)
+                self.request_cache.add(self.current_request)
+
+            return cast(ResponseT | None, result)

{pypck-0.9.7.dist-info → pypck-0.9.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.9.7
+Version: 0.9.9
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>

pypck-0.9.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+pypck/__init__.py,sha256=jVx-aBsV_LmBf6jiivMrMcBUofC_AOseywDafgOzAS4,323
+pypck/connection.py,sha256=n3itRe8oQtw64vyWGYhl6j4QJC6wgeeHitBSn-Cl2_4,23330
+pypck/device.py,sha256=1R9C4Wra8llzJph4eher-KPF2iF7uGOspq3eWcqTLyM,39591
+pypck/helpers.py,sha256=_5doqIsSRpqdQNPIUsjFh813xKGuMuEFY6sNGobJGIk,1280
+pypck/inputs.py,sha256=dw9ebhP9RBM9d-lPSFqRrFH1TOETNsT4RNschNjAnA8,46056
+pypck/lcn_addr.py,sha256=N2Od8KuANOglqKjf596hJVH1SRcG7MhESKA5YYlDnbw,1946
+pypck/lcn_defs.py,sha256=wSceYBwM46NqPwvff1hi8RluqUECmNY1gNcm1kDKTaI,43356
+pypck/pck_commands.py,sha256=SL9zpsswRGCHjAWm4uKWFTqtSBx2jURFHzq86QrtwuU,50442
+pypck/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypck/status_requester.py,sha256=Ea9c9moA1Kxoh3U9tPVqHKAmnRwq-1vraP_cwqxGZt8,5774
+pypck-0.9.9.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
+pypck-0.9.9.dist-info/METADATA,sha256=HER_BuajbZll66fngbD2rQVTR6bcice7kOMW8bOLggk,2682
+pypck-0.9.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pypck-0.9.9.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
+pypck-0.9.9.dist-info/RECORD,,

pypck-0.9.7.dist-info/RECORD

@@ -1,15 +0,0 @@
-pypck/__init__.py,sha256=jVx-aBsV_LmBf6jiivMrMcBUofC_AOseywDafgOzAS4,323
-pypck/connection.py,sha256=n3itRe8oQtw64vyWGYhl6j4QJC6wgeeHitBSn-Cl2_4,23330
-pypck/device.py,sha256=Ek-Zy4Id63vl43oW1pSafbDqRAfidhgoJI0F4EMWCXY,40375
-pypck/helpers.py,sha256=_5doqIsSRpqdQNPIUsjFh813xKGuMuEFY6sNGobJGIk,1280
-pypck/inputs.py,sha256=F7E8rprIhYzZnHARozt_hguYNgJaiNP3htrZ2E3Qa5I,45951
-pypck/lcn_addr.py,sha256=N2Od8KuANOglqKjf596hJVH1SRcG7MhESKA5YYlDnbw,1946
-pypck/lcn_defs.py,sha256=wSceYBwM46NqPwvff1hi8RluqUECmNY1gNcm1kDKTaI,43356
-pypck/pck_commands.py,sha256=eJxmh2e8EbKGpek97L2961Kr_nVfT8rKgJCN3YgjIQM,50458
-pypck/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypck/status_requester.py,sha256=10N5pbIBe_Ao-9ui_D7mCavk21BYZs9c-kxcTtmi-FI,5721
-pypck-0.9.7.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
-pypck-0.9.7.dist-info/METADATA,sha256=gooJ1CbK2mtAKuIEs8v3OKV_sDMHziMbmKHGPcEvsmE,2682
-pypck-0.9.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pypck-0.9.7.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
-pypck-0.9.7.dist-info/RECORD,,