zigpy 1.2.1__tar.gz → 1.3.0__tar.gz

{zigpy-1.2.1/zigpy.egg-info → zigpy-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy
-Version: 1.2.1
+Version: 1.3.0
 Summary: Library implementing a Zigbee stack
 Author-email: Russell Cloran <rcloran@gmail.com>
 License: GPL-3.0
@@ -16,7 +16,7 @@ Requires-Dist: crccheck
 Requires-Dist: cryptography
 Requires-Dist: voluptuous
 Requires-Dist: jsonschema
-Requires-Dist: pyserial-asyncio-fast
+Requires-Dist: serialx>=1.4.0
 Requires-Dist: typing_extensions
 Requires-Dist: frozendict
 Dynamic: license-file

{zigpy-1.2.1 → zigpy-1.3.0}/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
     "cryptography",
     "voluptuous",
     "jsonschema",
-    'pyserial-asyncio-fast',
+    "serialx>=1.4.0",
     "typing_extensions",
     "frozendict",
 ]

{zigpy-1.2.1 → zigpy-1.3.0}/tests/test_serial.py

@@ -54,7 +54,7 @@ async def test_serial_normal(
         kwargs["rtscts"] = rtscts
 
     with patch(
-        "zigpy.serial.pyserial_asyncio.create_serial_connection",
+        "zigpy.serial.serialx_create_serial_connection",
         AsyncMock(
             return_value=(AsyncMock(), AsyncMock())
         ),
@@ -71,32 +71,7 @@ async def test_serial_normal(
         assert mock_calls[0].kwargs[kwarg] == expected_kwargs[kwarg]
 
 
-async def test_serial_socket() -> None:
-    loop = asyncio.get_running_loop()
-    protocol_factory = Mock()
-
-    with patch.object(
-        loop,
-        "create_connection",
-        AsyncMock(
-            return_value=(AsyncMock(), AsyncMock())
-        ),
-    ):
-        await zigpy.serial.create_serial_connection(
-            loop, protocol_factory, "socket://1.2.3.4:5678"
-        )
-        await zigpy.serial.create_serial_connection(
-            loop, protocol_factory, "socket://1.2.3.4"
-        )
-
-        assert len(loop.create_connection.mock_calls) == 2
-        assert loop.create_connection.mock_calls[0].kwargs["host"] == "1.2.3.4"
-        assert loop.create_connection.mock_calls[0].kwargs["port"] == 5678
-        assert loop.create_connection.mock_calls[1].kwargs["host"] == "1.2.3.4"
-        assert loop.create_connection.mock_calls[1].kwargs["port"] == 6638
-
-
-async def test_pyserial_error_remapping(tmp_path: pathlib.Path) -> None:
+async def test_serial_error_remapping(tmp_path: pathlib.Path) -> None:
     loop = asyncio.get_running_loop()
     protocol_factory = Mock()
 
@@ -119,15 +94,6 @@ async def test_pyserial_error_remapping(tmp_path: pathlib.Path) -> None:
             loop, protocol_factory, url=denied_port
         )
 
-    # IsADirectoryError
-    a_folder = tmp_path / "a_folder"
-    a_folder.mkdir()
-
-    with pytest.raises(IsADirectoryError):
-        await zigpy.serial.create_serial_connection(
-            loop, protocol_factory, url=a_folder
-        )
-
     # Locked
     locked_port = tmp_path / "locked"
     with locked_port.open("w") as f:

{zigpy-1.2.1 → zigpy-1.3.0}/zigpy/event/event_base.py

@@ -9,7 +9,6 @@ from contextvars import ContextVar
 import dataclasses
 from inspect import iscoroutinefunction
 import logging
-import sys
 from typing import Any
 
 _LOGGER = logging.getLogger(__package__)
@@ -28,9 +27,7 @@ def suppress_events() -> Generator[None, None, None]:
         _suppress_events.reset(token)
 
 
-@dataclasses.dataclass(
-    frozen=True, **({"slots": True} if sys.version_info >= (3, 10) else {})
-)
+@dataclasses.dataclass(frozen=True, slots=True)
 class EventListener:
     """Listener for an event."""
 

{zigpy-1.2.1 → zigpy-1.3.0}/zigpy/ota/__init__.py

@@ -61,6 +61,21 @@ class OtaImageWithMetadata(t.BaseDataclassMixin):
     metadata: zigpy.ota.providers.BaseOtaImageMetadata
     firmware: BaseOTAImage | None
 
+    def __repr__(self) -> str:
+        if self.firmware is not None:
+            firmware_repr = (
+                f"<{type(self.firmware).__name__}: "
+                f"{self.firmware.header.image_size} bytes>"
+            )
+        else:
+            firmware_repr = "None"
+
+        return (
+            f"{type(self).__name__}("
+            f"metadata={self.metadata!r}, "
+            f"firmware={firmware_repr})"
+        )
+
     @property
     def version(self) -> int:
         return self.metadata.file_version

{zigpy-1.2.1 → zigpy-1.3.0}/zigpy/serial.py

@@ -1,26 +1,20 @@
 from __future__ import annotations
 
 import asyncio
-from asyncio import timeout as asyncio_timeout
+from collections.abc import Callable
+import errno
 import logging
 import pathlib
-import typing
-from typing import Literal
-import urllib.parse
-
-try:
-    # serialx is API-compatible with pyserial
-    import serialx as pyserial
-    import serialx as pyserial_asyncio
-except ImportError:
-    import serial as pyserial
-    import serial_asyncio_fast as pyserial_asyncio
+from typing import Any, Literal, cast
+
+from serialx import (
+    SerialTransport,
+    create_serial_connection as serialx_create_serial_connection,
+)
 
 from zigpy.typing import UNDEFINED, UndefinedType
 
 LOGGER = logging.getLogger(__name__)
-DEFAULT_SOCKET_PORT = 6638
-SOCKET_CONNECT_TIMEOUT = 5
 
 
 class SerialProtocol(asyncio.Protocol):
@@ -28,7 +22,7 @@ class SerialProtocol(asyncio.Protocol):
 
     def __init__(self) -> None:
         self._buffer = bytearray()
-        self._transport: pyserial_asyncio.SerialTransport | None = None
+        self._transport: SerialTransport | None = None
 
         self._connected_event = asyncio.Event()
         self._disconnected_event = asyncio.Event()
@@ -38,10 +32,10 @@ class SerialProtocol(asyncio.Protocol):
         """Wait for the protocol's transport to be connected."""
         await self._connected_event.wait()
 
-    def connection_made(self, transport: pyserial_asyncio.SerialTransport) -> None:
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
         LOGGER.debug("Connection made: %s", transport)
 
-        self._transport = transport
+        self._transport = cast(SerialTransport, transport)
         self._disconnected_event.clear()
         self._connected_event.set()
 
@@ -70,20 +64,17 @@ class SerialProtocol(asyncio.Protocol):
 
 
 async def create_serial_connection(
-    loop: asyncio.BaseEventLoop,
-    protocol_factory: typing.Callable[[], asyncio.Protocol],
+    loop: asyncio.AbstractEventLoop,
+    protocol_factory: Callable[[], asyncio.Protocol],
     url: pathlib.Path | str,
     *,
     baudrate: int = 115200,  # We default to 115200 instead of 9600
-    exclusive: bool | None = True,
     xonxoff: bool | UndefinedType = UNDEFINED,
     rtscts: bool | UndefinedType = UNDEFINED,
     flow_control: Literal["hardware", "software"] | None | UndefinedType = UNDEFINED,
-    **kwargs: typing.Any,
+    **kwargs: Any,
 ) -> tuple[asyncio.Transport, asyncio.Protocol]:
-    """Wrapper around pyserial-asyncio that transparently substitutes a normal TCP
-    transport and protocol when a `socket` connection URI is provided.
-    """
+    """Wrapper for serialx that provides simplified flow control kwargs."""
 
     if flow_control is not UNDEFINED:
         xonxoff = flow_control == "software"
@@ -104,38 +95,24 @@ async def create_serial_connection(
     )
 
     url = str(url)
-    parsed_url = urllib.parse.urlparse(url)
-
-    if parsed_url.scheme in ("socket", "tcp"):
-        async with asyncio_timeout(SOCKET_CONNECT_TIMEOUT):
-            transport, protocol = await loop.create_connection(
-                protocol_factory=protocol_factory,
-                host=parsed_url.hostname,
-                port=parsed_url.port or DEFAULT_SOCKET_PORT,
-            )
-    else:
-        try:
-            try:
-                transport, protocol = await pyserial_asyncio.create_serial_connection(
-                    loop,
-                    protocol_factory,
-                    url=url,
-                    baudrate=baudrate,
-                    exclusive=exclusive,
-                    xonxoff=xonxoff,
-                    rtscts=rtscts,
-                    **kwargs,
-                )
-            except pyserial.SerialException as exc:
-                # Unwrap unnecessarily wrapped PySerial exceptions
-                if exc.__context__ is not None:
-                    raise exc.__context__ from None
-
-                raise
-        except BlockingIOError as exc:
+
+    try:
+        transport, protocol = await serialx_create_serial_connection(
+            loop,
+            protocol_factory,
+            url=url,
+            baudrate=baudrate,
+            xonxoff=xonxoff,
+            rtscts=rtscts,
+            **kwargs,
+        )
+    except OSError as exc:
+        if exc.errno == errno.EBUSY:
             # Re-raise a more useful exception
             raise PermissionError(
                 "The serial port is locked by another application"
             ) from exc
 
+        raise
+
     return transport, protocol

{zigpy-1.2.1 → zigpy-1.3.0/zigpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy
-Version: 1.2.1
+Version: 1.3.0
 Summary: Library implementing a Zigbee stack
 Author-email: Russell Cloran <rcloran@gmail.com>
 License: GPL-3.0
@@ -16,7 +16,7 @@ Requires-Dist: crccheck
 Requires-Dist: cryptography
 Requires-Dist: voluptuous
 Requires-Dist: jsonschema
-Requires-Dist: pyserial-asyncio-fast
+Requires-Dist: serialx>=1.4.0
 Requires-Dist: typing_extensions
 Requires-Dist: frozendict
 Dynamic: license-file

{zigpy-1.2.1 → zigpy-1.3.0}/zigpy.egg-info/requires.txt

@@ -5,6 +5,6 @@ crccheck
 cryptography
 voluptuous
 jsonschema
-pyserial-asyncio-fast
+serialx>=1.4.0
 typing_extensions
 frozendict