androidtvremote2 0.3.1__tar.gz → 0.3.2__tar.gz

{androidtvremote2-0.3.1/src/androidtvremote2.egg-info → androidtvremote2-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: androidtvremote2
-Version: 0.3.1
+Version: 0.3.2
 Summary: A Python library for interacting with Android TV using the Android TV Remote protocol v2
 Author-email: tronikos <tronikos@gmail.com>
 License-Expression: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Dist: cryptography>=3
 Requires-Dist: protobuf>=4.21
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
 Provides-Extra: demo
 Requires-Dist: pyaudio; extra == "demo"
 Requires-Dist: pynput; extra == "demo"

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "androidtvremote2"
-version = "0.3.1"
+version = "0.3.2"
 license = "Apache-2.0"
 authors = [
     { name="tronikos", email="tronikos@gmail.com" },
@@ -17,6 +17,7 @@ dependencies = [
 [project.optional-dependencies]
 test = [
     "pytest",
+    "pytest-asyncio",
 ]
 demo = [
     "pyaudio",
@@ -33,6 +34,15 @@ demo = [
 requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
+# Explicit discovery. Without it setuptools also picks up src/demo.py and installs it
+# as a top level "demo" module.
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.ruff]
 target-version = "py310"
 line-length = 127
@@ -70,6 +80,7 @@ ignore = [
     "D203",  # 1 blank line required before class docstring
     "D213",  # Multi-line docstring summary should start at the second line
     "PLR0913",  # Too many arguments in function definition
+    "PLR0917",  # Too many positional arguments in function definition
     "PLR1714",  # Consider merging multiple comparisons
     "PLR2004",  # Magic value used in comparison
     "TRY003",  # Avoid specifying long messages outside the exception class

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/__init__.py

@@ -1,7 +1,7 @@
 """Library implementing the Android TV Remote protocol."""
 
 from .androidtv_remote import AndroidTVRemote
-from .exceptions import CannotConnect, ConnectionClosed, InvalidAuth
+from .exceptions import CannotConnect, ConnectionClosed, InvalidAuth, VoiceSessionInProgress
 from .model import DeviceInfo, VolumeInfo
 from .voice_stream import VoiceStream
 
@@ -11,6 +11,7 @@ __all__ = [
     "ConnectionClosed",
     "DeviceInfo",
     "InvalidAuth",
+    "VoiceSessionInProgress",
     "VoiceStream",
     "VolumeInfo",
 ]

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/androidtv_remote.py

@@ -25,6 +25,31 @@ if TYPE_CHECKING:
     from .model import DeviceInfo, VolumeInfo
 
 
+def _parse_name_and_mac(server_cert: x509.Certificate) -> tuple[str, str]:
+    """Extract the name and MAC address from the subject of an Android TV certificate.
+
+    NVIDIA SHIELD example:
+    CN=atvremote/darcy/darcy/SHIELD Android TV/XX:XX:XX:XX:XX:XX
+    Nexus Player example:
+    dnQualifier=fugu/fugu/Nexus Player/CN=atvremote/XX:XX:XX:XX:XX:XX
+    """
+    common_name = server_cert.subject.get_attributes_for_oid(x509.OID_COMMON_NAME)
+    common_name_str = str(common_name[0].value) if common_name else ""
+    dn_qualifier = server_cert.subject.get_attributes_for_oid(x509.OID_DN_QUALIFIER)
+    dn_qualifier_str = str(dn_qualifier[0].value) if dn_qualifier else ""
+    common_name_parts = common_name_str.split("/")
+    dn_qualifier_parts = dn_qualifier_str.split("/")
+    if dn_qualifier_str:
+        name = dn_qualifier_parts[-1]
+    elif len(common_name_parts) > 1:
+        name = common_name_parts[-2]
+    else:
+        # Unexpected subject, e.g. a common name without any "/" separator.
+        name = common_name_str
+    mac = common_name_parts[-1]
+    return name, mac
+
+
 def _load_cert_chain(certfile: str, keyfile: str) -> ssl.SSLContext:
     ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
     ssl_context.check_hostname = False
@@ -196,6 +221,8 @@ class AndroidTVRemote:
             await out.write(cert_pem.decode("utf-8"))
         async with aiofiles.open(self._keyfile, "w", encoding="utf-8") as out:
             await out.write(key_pem.decode("utf-8"))
+        # The cached context, if any, was loaded from the previous certificate.
+        self._ssl_context = None
         return True
 
     async def _create_ssl_context(self) -> ssl.SSLContext:
@@ -297,8 +324,7 @@ class AndroidTVRemote:
         if self._reconnect_task:
             self._reconnect_task.cancel()
         if self._remote_message_protocol:
-            if self._remote_message_protocol.transport:
-                self._remote_message_protocol.transport.close()
+            self._remote_message_protocol.close()
             self._remote_message_protocol = None
         if self._pairing_message_protocol:
             if self._pairing_message_protocol.transport:
@@ -318,20 +344,11 @@ class AndroidTVRemote:
             raise CannotConnect from exc
         server_cert_bytes = writer.transport.get_extra_info("ssl_object").getpeercert(True)
         writer.close()
-        server_cert = x509.load_der_x509_certificate(server_cert_bytes)
-        # NVIDIA SHIELD example:
-        # CN=atvremote/darcy/darcy/SHIELD Android TV/XX:XX:XX:XX:XX:XX
-        # Nexus Player example:
-        # dnQualifier=fugu/fugu/Nexus Player/CN=atvremote/XX:XX:XX:XX:XX:XX
-        common_name = server_cert.subject.get_attributes_for_oid(x509.OID_COMMON_NAME)
-        common_name_str = str(common_name[0].value) if common_name else ""
-        dn_qualifier = server_cert.subject.get_attributes_for_oid(x509.OID_DN_QUALIFIER)
-        dn_qualifier_str = str(dn_qualifier[0].value) if dn_qualifier else ""
-        common_name_parts = common_name_str.split("/")
-        dn_qualifier_parts = dn_qualifier_str.split("/")
-        name = dn_qualifier_parts[-1] if dn_qualifier_str else common_name_parts[-2]
-        mac = common_name_parts[-1]
-        return name, mac
+        try:
+            await writer.wait_closed()
+        except OSError as exc:
+            LOGGER.debug("Error closing connection to %s:%s. %s", self.host, self._pair_port, exc)
+        return _parse_name_and_mac(x509.load_der_x509_certificate(server_cert_bytes))
 
     async def async_start_pairing(self) -> None:
         """Start the pairing process.
@@ -426,8 +443,8 @@ class AndroidTVRemote:
 
         :param timeout: optional timeout for session readiness. Defaults to 2 seconds.
         :raises ConnectionClosed: if client is disconnected.
-        :raises asyncio.TimeoutError: if the device does not begin voice in time, or a voice
-                                      session is already in progress.
+        :raises VoiceSessionInProgress: if a voice session is already in progress.
+        :raises asyncio.TimeoutError: if the device does not begin voice in time.
         """
         if not self._remote_message_protocol:
             LOGGER.debug("Called start_voice after disconnect")

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/base.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, cast
 from google.protobuf import text_format
 from google.protobuf.internal.decoder import _DecodeVarint  # type: ignore[attr-defined]
 from google.protobuf.internal.encoder import _EncodeVarint  # type: ignore[attr-defined]
+from google.protobuf.message import DecodeError
 
 from .const import LOGGER
 
@@ -25,8 +26,7 @@ class ProtobufProtocol(asyncio.Protocol):
         """
         self.on_con_lost = on_con_lost
         self.transport: asyncio.Transport | None = None
-        self._raw_msg_len = -1
-        self._raw_msg = b""
+        self._buffer = bytearray()
 
     def connection_made(self, transport: asyncio.BaseTransport) -> None:
         """Store transport when a connection is made."""
@@ -40,27 +40,37 @@ class ProtobufProtocol(asyncio.Protocol):
             self.on_con_lost.set_result(exc)
 
     def data_received(self, data: bytes) -> None:
-        """Receive data until a full protobuf is received and pass it to _handle_message."""
+        """Buffer data and pass every complete protobuf message to _handle_message.
+
+        Messages are length delimited by a varint. A single call may deliver a partial
+        message, several messages, or anything in between, and the split can happen
+        anywhere, including in the middle of the varint.
+        """
         if not data:
             LOGGER.debug("No data received")
             return
-        if self._raw_msg_len < 0:
-            self._raw_msg_len, pos = _DecodeVarint(data, 0)
-            pos_end = pos + self._raw_msg_len
-            self._raw_msg += data[pos:pos_end]
-            remaining_data = data[pos_end:]
-        else:
-            pos_end = self._raw_msg_len - len(self._raw_msg)
-            self._raw_msg += data[:pos_end]
-            remaining_data = data[pos_end:]
-        if self._raw_msg_len == len(self._raw_msg):
-            raw_msg = self._raw_msg
-            self._raw_msg_len = -1
-            self._raw_msg = b""
+        self._buffer += data
+        while self._buffer:
+            try:
+                msg_len, pos = _DecodeVarint(self._buffer, 0)
+            except IndexError:
+                # The varint with the message length was not fully received yet.
+                return
+            except DecodeError as exc:
+                # The stream cannot be resynchronized after a corrupt length.
+                LOGGER.debug("Couldn't decode the message length. %s", exc)
+                self._buffer.clear()
+                if self.transport and not self.transport.is_closing():
+                    self.transport.close()
+                return
+            pos_end = pos + msg_len
+            if len(self._buffer) < pos_end:
+                # The message was not fully received yet.
+                return
+            raw_msg = bytes(self._buffer[pos:pos_end])
+            del self._buffer[:pos_end]
             # LOGGER.debug("Received: %s", raw_msg)
             self._handle_message(raw_msg)
-            if remaining_data:
-                self.data_received(remaining_data)
 
     def _handle_message(self, raw_msg: bytes) -> None:
         """Handle a message from the server. Message needs to be parsed to the appropriate protobuf."""

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/certificate_generator.py

@@ -6,7 +6,7 @@
 
 from __future__ import annotations
 
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from cryptography import x509
 from cryptography.hazmat.backends import default_backend
@@ -29,7 +29,7 @@ def generate_selfsigned_cert(hostname: str) -> tuple[bytes, bytes]:
     alt_names = [x509.DNSName(hostname)]
     san = x509.SubjectAlternativeName(alt_names)
     basic_constraints = x509.BasicConstraints(ca=True, path_length=0)
-    now = datetime.utcnow()
+    now = datetime.now(timezone.utc)
     cert = (
         x509.CertificateBuilder()
         .subject_name(name)

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/exceptions.py

@@ -11,3 +11,7 @@ class ConnectionClosed(Exception):
 
 class InvalidAuth(Exception):
     """Error to indicate there is invalid auth."""
+
+
+class VoiceSessionInProgress(Exception):
+    """Error to indicate a voice session is already in progress."""

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/pairing.py

@@ -21,6 +21,10 @@ from .const import LOGGER
 from .exceptions import ConnectionClosed, InvalidAuth
 from .polo_pb2 import Options, OuterMessage
 
+# Timeout in seconds to wait for a response from the Android TV. Every step of the
+# pairing handshake is answered by the device itself, so this doesn't wait on a human.
+PAIRING_TIMEOUT = 10.0
+
 
 def _create_message() -> OuterMessage:
     """Create an OuterMessage with default values."""
@@ -69,7 +73,7 @@ class PairingProtocol(ProtobufProtocol):
     async def async_start_pairing(self) -> None:
         """Start the pairing process.
 
-        :raises ConnectionClosed: if connection was lost.
+        :raises ConnectionClosed: if connection was lost or the device didn't respond in time.
         """
         self._raise_if_not_connected()
         msg = _create_message()
@@ -86,7 +90,7 @@ class PairingProtocol(ProtobufProtocol):
         """Finish the pairing process.
 
         :param pairing_code: pairing code shown on the Android TV.
-        :raises ConnectionClosed: if connection was lost.
+        :raises ConnectionClosed: if connection was lost or the device didn't respond in time.
         :raises InvalidAuth: if pairing was unsuccessful.
         """
         self._raise_if_not_connected()
@@ -129,9 +133,18 @@ class PairingProtocol(ProtobufProtocol):
         finally:
             self._on_pairing_finished = None
 
-    async def _async_wait_for_future_or_con_lost(self, future: asyncio.Future[Any]) -> None:
-        """Wait for future to finish or connection to be lost."""
-        await asyncio.wait((self.on_con_lost, future), return_when=asyncio.FIRST_COMPLETED)
+    async def _async_wait_for_future_or_con_lost(self, future: asyncio.Future[Any], timeout: float = PAIRING_TIMEOUT) -> None:
+        """Wait for future to finish, connection to be lost, or timeout to elapse.
+
+        :raises ConnectionClosed: if the connection was lost or the device stopped responding.
+        """
+        done, _pending = await asyncio.wait((self.on_con_lost, future), timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
+        if not done:
+            LOGGER.debug("Timeout after %s seconds waiting for a response while pairing", timeout)
+            future.cancel()
+            if self.transport:
+                self.transport.close()
+            raise ConnectionClosed(f"No response from the Android TV within {timeout} seconds")
         if future.done():
             if future.exception():
                 raise ConnectionClosed(future.exception())
@@ -177,11 +190,11 @@ class PairingProtocol(ProtobufProtocol):
             new_msg.configuration.encoding.type = Options.Encoding.ENCODING_TYPE_HEXADECIMAL
             new_msg.configuration.encoding.symbol_length = 6
         elif msg.HasField("configuration_ack"):
-            if self._on_pairing_started:
+            if self._on_pairing_started and not self._on_pairing_started.done():
                 self._on_pairing_started.set_result(True)
             return
         elif msg.HasField("secret_ack"):
-            if self._on_pairing_finished:
+            if self._on_pairing_finished and not self._on_pairing_finished.done():
                 self._on_pairing_finished.set_result(True)
             return
         else:

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2/remote.py

@@ -15,7 +15,7 @@ from google.protobuf.message import DecodeError
 
 from .base import ProtobufProtocol
 from .const import LOGGER
-from .exceptions import ConnectionClosed
+from .exceptions import ConnectionClosed, VoiceSessionInProgress
 from .remotemessage_pb2 import (
     RemoteDirection,
     RemoteEditInfo,
@@ -115,9 +115,22 @@ class RemoteProtocol(ProtobufProtocol):
         self._loop = loop
         self._idle_disconnect_task: asyncio.Task[None] | None = None
         self._reset_idle_disconnect_task()
-        self._voice_lock = asyncio.Lock()
+        self._voice_starting = False
+        self._voice_session_id: int | None = None
         self._on_voice_begin: asyncio.Future[int] | None = None
 
+    def connection_lost(self, exc: Exception | None) -> None:
+        """Cancel the idle disconnect task and drop any voice session."""
+        self._cancel_idle_disconnect_task()
+        self._voice_session_id = None
+        super().connection_lost(exc)
+
+    def close(self) -> None:
+        """Close the connection and stop the idle disconnect task."""
+        self._cancel_idle_disconnect_task()
+        if self.transport and not self.transport.is_closing():
+            self.transport.close()
+
     @property
     def is_voice_enabled(self) -> bool:
         """Voice commands enabled.
@@ -134,7 +147,7 @@ class RemoteProtocol(ProtobufProtocol):
 
         :param key_code: int (e.g. 26) or str (e.g. "KEYCODE_POWER" or just "POWER") from the enum
                          RemoteKeyCode in remotemessage.proto or str prefixed with "text:" to pass
-                         to send_text.
+                         to send_text. Key codes and directions are case insensitive.
         :param direction: "SHORT" (default) or "START_LONG" or "END_LONG".
         :raises ValueError: if key_code in str or direction isn't known.
         """
@@ -143,11 +156,12 @@ class RemoteProtocol(ProtobufProtocol):
         if isinstance(key_code, str):
             if key_code.lower().startswith(TEXT_PREFIX):
                 return self.send_text(key_code[len(TEXT_PREFIX) :])
+            key_code = key_code.upper()
             if not key_code.startswith(KEYCODE_PREFIX):
                 key_code = KEYCODE_PREFIX + key_code
             key_code = RemoteKeyCode.Value(key_code)
         if isinstance(direction, str):
-            direction = RemoteDirection.Value(direction)
+            direction = RemoteDirection.Value(direction.upper())
         msg.remote_key_inject.key_code = key_code  # type: ignore[assignment]
         msg.remote_key_inject.direction = direction  # type: ignore[assignment]
         self._send_message(msg)
@@ -156,7 +170,7 @@ class RemoteProtocol(ProtobufProtocol):
     def send_text(self, text: str) -> None:
         """Send a text string to Android TV via the input method.
 
-        The text length is used for both `start` and `end` in the RemoteImeObject.
+        The text length minus one is used for both `start` and `end` in the RemoteImeObject.
         The `ime_counter` and `ime_field_counter` values are taken from self (batch_edit_info response),
         which is populated when a message with a remote_ime_batch_edit field is received.
 
@@ -195,20 +209,22 @@ class RemoteProtocol(ProtobufProtocol):
         initial ``remote_voice_begin`` message back to the device, as required by the
         protocol, so the caller can start streaming audio chunks.
 
+        The session stays open until :meth:`end_voice` is called for it, and only one
+        session can be open at a time.
+
         :param timeout: Optional timeout in seconds for session readiness. Defaults to 2 seconds.
         :raises ConnectionClosed: If the connection is lost.
-        :raises asyncio.TimeoutError: If the operation times out or a voice session is already in
-                                      progress.
+        :raises VoiceSessionInProgress: If a voice session is already in progress.
+        :raises asyncio.TimeoutError: If the operation times out.
         :return: The voice session id, which must be used in later calls to ``send_voice_chunk``.
         """
         if self.transport is None or self.transport.is_closing():
             raise ConnectionClosed("Connection has been lost")
 
-        if self._voice_lock.locked():
-            raise asyncio.TimeoutError("Voice session already in progress")
-
-        await self._voice_lock.acquire()
+        if self._voice_starting or self._voice_session_id is not None:
+            raise VoiceSessionInProgress("Voice session already in progress")
 
+        self._voice_starting = True
         self._on_voice_begin = self._loop.create_future()
         try:
             self.send_key_command(RemoteKeyCode.KEYCODE_SEARCH)
@@ -219,12 +235,11 @@ class RemoteProtocol(ProtobufProtocol):
             begin = RemoteMessage()
             begin.remote_voice_begin.session_id = session_id
             self._send_message(begin)
-            return int(session_id)
-        except:
-            self._on_voice_begin = None
-            raise
+            self._voice_session_id = int(session_id)
+            return self._voice_session_id
         finally:
-            self._voice_lock.release()
+            self._voice_starting = False
+            self._on_voice_begin = None
 
     def send_voice_chunk(self, chunk: bytes, session_id: int) -> None:
         """Send a chunk of PCM audio for the active voice session.
@@ -236,15 +251,16 @@ class RemoteProtocol(ProtobufProtocol):
         if self.transport is None or self.transport.is_closing():
             raise ConnectionClosed("Connection has been lost")
 
-        # Pad chunk to minimum chunk size
-        if len(chunk) < VOICE_CHUNK_MIN_SIZE:
-            chunk = chunk + b"\x00" * (VOICE_CHUNK_MIN_SIZE - len(chunk))
-
         # Limit chunk size, otherwise Android TV will close the connection
         for i in range(0, len(chunk), VOICE_CHUNK_SIZE):
+            samples = bytes(chunk[i : i + VOICE_CHUNK_SIZE])
+            # Pad to the minimum chunk size. This has to happen after splitting, since
+            # the last piece of a larger chunk can be smaller than the minimum as well.
+            if len(samples) < VOICE_CHUNK_MIN_SIZE:
+                samples = samples.ljust(VOICE_CHUNK_MIN_SIZE, b"\x00")
             msg = RemoteMessage()
             msg.remote_voice_payload.session_id = session_id
-            msg.remote_voice_payload.samples = chunk[i : i + VOICE_CHUNK_SIZE]
+            msg.remote_voice_payload.samples = samples
             self._send_message(msg, False)  # disable logging of voice data
 
     def end_voice(self, session_id: int) -> None:
@@ -255,6 +271,8 @@ class RemoteProtocol(ProtobufProtocol):
         end = RemoteMessage()
         end.remote_voice_end.session_id = session_id
         self._send_message(end)
+        if self._voice_session_id == session_id:
+            self._voice_session_id = None
 
     def _handle_message(self, raw_msg: bytes) -> None:  # noqa: PLR0912,PLR0915
         """Handle a message from the server."""
@@ -313,6 +331,11 @@ class RemoteProtocol(ProtobufProtocol):
         elif msg.HasField("remote_ping_request"):
             new_msg.remote_ping_response.val1 = msg.remote_ping_request.val1
             log_send = LOG_PING_REQUESTS
+        elif msg.HasField("remote_error"):
+            LOGGER.error(
+                "Received an error from the device: %s",
+                text_format.MessageToString(msg.remote_error, as_one_line=True),
+            )
         elif msg.HasField("remote_voice_begin"):
             if self._on_voice_begin and not self._on_voice_begin.done():
                 self._on_voice_begin.set_result(msg.remote_voice_begin.session_id)
@@ -324,9 +347,16 @@ class RemoteProtocol(ProtobufProtocol):
         if new_msg != RemoteMessage():
             self._send_message(new_msg, log_send)
 
-    def _reset_idle_disconnect_task(self) -> None:
+    def _cancel_idle_disconnect_task(self) -> None:
         if self._idle_disconnect_task is not None:
             self._idle_disconnect_task.cancel()
+            self._idle_disconnect_task = None
+
+    def _reset_idle_disconnect_task(self) -> None:
+        self._cancel_idle_disconnect_task()
+        if self.transport is not None and self.transport.is_closing():
+            # Don't keep a task alive for a connection that is going away.
+            return
         self._idle_disconnect_task = self._loop.create_task(self._async_idle_disconnect())
 
     async def _async_idle_disconnect(self) -> None:

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2/src/androidtvremote2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: androidtvremote2
-Version: 0.3.1
+Version: 0.3.2
 Summary: A Python library for interacting with Android TV using the Android TV Remote protocol v2
 Author-email: tronikos <tronikos@gmail.com>
 License-Expression: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Dist: cryptography>=3
 Requires-Dist: protobuf>=4.21
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
 Provides-Extra: demo
 Requires-Dist: pyaudio; extra == "demo"
 Requires-Dist: pynput; extra == "demo"

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-src/demo.py
 src/androidtvremote2/__init__.py
 src/androidtvremote2/androidtv_remote.py
 src/androidtvremote2/base.py
@@ -22,4 +21,9 @@ src/androidtvremote2.egg-info/SOURCES.txt
 src/androidtvremote2.egg-info/dependency_links.txt
 src/androidtvremote2.egg-info/requires.txt
 src/androidtvremote2.egg-info/top_level.txt
-tests/test_androidtv_remote.py
+tests/test_androidtv_remote.py
+tests/test_base.py
+tests/test_certificate_generator.py
+tests/test_pairing.py
+tests/test_remote.py
+tests/test_voice_stream.py

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2.egg-info/requires.txt

@@ -9,3 +9,4 @@ zeroconf
 
 [test]
 pytest
+pytest-asyncio

{androidtvremote2-0.3.1 → androidtvremote2-0.3.2}/src/androidtvremote2.egg-info/top_level.txt

@@ -1,2 +1 @@
 androidtvremote2
-demo