fix pyrefly typecheck in CI

Author: Nkovaturient

libp2p/transport/webrtc/async_bridge.py

@@ -79,8 +79,7 @@ async def create_offer(
     ) -> RTCSessionDescription:
         """Create SDP offer with proper async bridging"""
         try:
-            create_offer = aio_as_trio(peer_connection.createOffer)
-            offer = await create_offer()
+            offer = await aio_as_trio(peer_connection.createOffer())
             logger.debug("Successfully created SDP offer")
             return offer
         except Exception as e:
@@ -92,8 +91,7 @@ async def create_answer(
     ) -> RTCSessionDescription:
         """Create SDP answer with proper async bridging"""
         try:
-            create_answer = aio_as_trio(peer_connection.createAnswer)
-            answer = await create_answer()
+            answer = await aio_as_trio(peer_connection.createAnswer())
             logger.debug("Successfully created SDP answer")
             return answer
         except Exception as e:
@@ -105,8 +103,7 @@ async def set_local_description(
     ) -> None:
         """Set local description with proper async bridging"""
         try:
-            set_local = aio_as_trio(peer_connection.setLocalDescription)
-            await set_local(description)
+            await aio_as_trio(peer_connection.setLocalDescription(description))
             logger.debug("Successfully set local description")
         except Exception as e:
             logger.error(f"Failed to set local description: {e}")
@@ -117,8 +114,7 @@ async def set_remote_description(
     ) -> None:
         """Set remote description with proper async bridging"""
         try:
-            set_remote = aio_as_trio(peer_connection.setRemoteDescription)
-            await set_remote(description)
+            await aio_as_trio(peer_connection.setRemoteDescription(description))
             logger.debug("Successfully set remote description")
         except Exception as e:
             logger.error(f"Failed to set remote description: {e}")
@@ -129,8 +125,7 @@ async def add_ice_candidate(
     ) -> None:
         """Add ICE candidate with proper async bridging"""
         try:
-            add_candidate = aio_as_trio(peer_connection.addIceCandidate)
-            await add_candidate(candidate)
+            await aio_as_trio(peer_connection.addIceCandidate(candidate))
             logger.debug("Successfully added ICE candidate")
         except Exception as e:
             logger.error(f"Failed to add ICE candidate: {e}")
@@ -139,8 +134,7 @@ async def add_ice_candidate(
     async def close_peer_connection(self, peer_connection: RTCPeerConnection) -> None:
         """Close peer connection with proper async bridging"""
         try:
-            close_pc = aio_as_trio(peer_connection.close)
-            await close_pc()
+            await aio_as_trio(peer_connection.close())
             logger.debug("Successfully closed peer connection")
         except Exception as e:
             logger.error(f"Failed to close peer connection: {e}")
@@ -149,8 +143,7 @@ async def close_peer_connection(self, peer_connection: RTCPeerConnection) -> Non
     async def close_data_channel(self, data_channel: RTCDataChannel) -> None:
         """Close data channel with proper async bridging"""
         try:
-            close_channel = aio_as_trio(data_channel.close)
-            await close_channel()
+            await aio_as_trio(data_channel.close)
             logger.debug("Successfully closed data channel")
         except Exception as e:
             logger.error(f"Failed to close data channel: {e}")
@@ -159,8 +152,7 @@ async def close_data_channel(self, data_channel: RTCDataChannel) -> None:
     async def send_data(self, data_channel: RTCDataChannel, data: bytes) -> None:
         """Send data through channel with proper async bridging"""
         try:
-            send_data = aio_as_trio(data_channel.send)
-            await send_data(data)
+            aio_as_trio(data_channel.send)(data)
             logger.debug(f"Successfully sent {len(data)} bytes")
         except Exception as e:
             logger.error(f"Failed to send data: {e}")
@@ -250,7 +242,6 @@ async def cleanup_webrtc_resources(*resources: Any) -> None:
                         elif isinstance(resource, RTCDataChannel):
                             await bridge.close_data_channel(resource)
                         else:
-                            close_fn = aio_as_trio(resource.close)
-                            await close_fn()
+                            await aio_as_trio(resource.close())
                 except Exception as e:
                     logger.warning(f"Error cleaning up resource {type(resource)}: {e}")

libp2p/transport/webrtc/connection.py

@@ -147,7 +147,7 @@ def __init__(
 
         # Stream muxing
         self._streams: dict[int, WebRTCStream] = {}
-        self._next_stream_id = (
+        self._next_stream_id: int = (
             1 if is_initiator else 2
         )  # Odd for initiator, even for responder
         self._stream_lock = trio.Lock()

libp2p/transport/webrtc/gen_certificate.py

@@ -2,6 +2,7 @@
 import datetime
 import hashlib
 import logging
+from typing import Any
 
 import base58
 from cryptography import (
@@ -59,9 +60,10 @@ def generate(cls) -> "WebRTCCertificate":
         )
 
         # Create certificate
+        common_name: Any = "libp2p-webrtc"
         subject = issuer = x509.Name(
             [
-                x509.NameAttribute(NameOID.COMMON_NAME, "libp2p-webrtc"),
+                x509.NameAttribute(NameOID.COMMON_NAME, common_name),
             ]
         )
 
@@ -151,8 +153,9 @@ def validate_pem_export(self) -> bool:
 
         # 3. Key-certificate matching (RSA-specific validation)
         cert_public_key = cert_obj.public_key()
-        if hasattr(cert_public_key, "public_numbers") and hasattr(
-            key_obj.public_key(), "public_numbers"
+        # Only check public_numbers for RSA keys
+        if isinstance(cert_public_key, rsa.RSAPublicKey) and isinstance(
+            key_obj.public_key(), rsa.RSAPublicKey
         ):
             if (
                 cert_public_key.public_numbers()
@@ -235,7 +238,7 @@ def create_webrtc_direct_multiaddr(ip: str, port: int, peer_id: ID) -> Multiaddr
     return Multiaddr(f"/ip4/{ip}/udp/{port}/webrtc-direct/p2p/{peer_id}")
 
 
-def parse_webrtc_maddr(maddr: Multiaddr) -> tuple[str, ID, str]:
+def parse_webrtc_maddr(maddr: Multiaddr | str) -> tuple[str, str, str]:
     """
     Parse a WebRTC multiaddr like:
     /ip4/147.28.186.157/udp/9095/webrtc-direct/certhash/uEiDFVmAomKdAbivdrcIKdXGyuij_ax8b8at0GY_MJXMlwg/p2p/12D3KooWFhXabKDwALpzqMbto94sB7rvmZ6M28hs9Y9xSopDKwQr/p2p-circuit
@@ -248,7 +251,8 @@ def parse_webrtc_maddr(maddr: Multiaddr) -> tuple[str, ID, str]:
         if isinstance(maddr, str):
             maddr = Multiaddr(maddr)
 
-        parts = maddr.to_string().split("/")
+        # Use str() instead of to_string() method
+        parts = str(maddr).split("/")
 
         # Get IP (after ip4 or ip6)
         ip_idx = parts.index("ip4" if "ip4" in parts else "ip6") + 1

libp2p/transport/webrtc/multiaddr_codecs.py

@@ -7,34 +7,33 @@
 
 import base64
 from collections.abc import ByteString
-from typing import LiteralString
 
 
-def webrtc_encode(s: LiteralString) -> ByteString:
+def webrtc_encode(s: str) -> ByteString:
     """Encode WebRTC protocol component."""
     # WebRTC protocol has no value, return empty bytes
     return b""
 
 
-def webrtc_decode(b: ByteString) -> LiteralString:
+def webrtc_decode(b: ByteString) -> str:
     """Decode WebRTC protocol component."""
     # WebRTC protocol has no value, return empty string
     return ""
 
 
-def webrtc_direct_encode(s: LiteralString) -> ByteString:
+def webrtc_direct_encode(s: str) -> ByteString:
     """Encode WebRTC-Direct protocol component."""
     # WebRTC-Direct protocol has no value, return empty bytes
     return b""
 
 
-def webrtc_direct_decode(b: ByteString) -> LiteralString:
+def webrtc_direct_decode(b: ByteString) -> str:
     """Decode WebRTC-Direct protocol component."""
     # WebRTC-Direct protocol has no value, return empty string
     return ""
 
 
-def certhash_encode(s: LiteralString) -> ByteString:
+def certhash_encode(s: str) -> ByteString:
     """Encode certificate hash component."""
     if not s:
         return b""
@@ -59,7 +58,7 @@ def certhash_encode(s: LiteralString) -> ByteString:
         return s.encode("utf-8")
 
 
-def certhash_decode(b: ByteString) -> LiteralString:
+def certhash_decode(b: ByteString) -> str:
     """Decode certificate hash component."""
     if not b:
         return ""

libp2p/transport/webrtc/private_to_private/initiate_connection.py

@@ -46,12 +46,11 @@ async def initiate_connection(
     logger.info(f"Initiating WebRTC connection to {maddr}")
 
     # Parse circuit relay multiaddr to get target peer ID
-    protocols = maddr.protocols()
+    protocols = [p for p in maddr.protocols() if p is not None]
     target_peer_id = None
     for i, protocol in enumerate(protocols):
         if protocol.name == "p2p":
             if i + 1 < len(protocols) and protocols[i + 1].name == "p2p-circuit":
-                # This is the relay peer, continue
                 continue
             else:
                 # This is the target peer
@@ -69,7 +68,20 @@ async def initiate_connection(
 
     try:
         # Establish signaling stream through circuit relay
-        signaling_stream = await host.new_stream(maddr, [SIGNALING_PROTOCOL])
+        # Note: new_stream expects peer_id, not multiaddr
+        # We need to extract the relay peer ID from the multiaddr
+        relay_peer_id = None
+        for i, protocol in enumerate(protocols):
+            if protocol.name == "p2p":
+                if i + 1 < len(protocols) and protocols[i + 1].name == "p2p-circuit":
+                    # This is the relay peer
+                    relay_peer_id = ID.from_base58(maddr.value_for_protocol("p2p"))
+                    break
+
+        if not relay_peer_id:
+            raise WebRTCError(f"Cannot extract relay peer ID from multiaddr: {maddr}")
+
+        signaling_stream = await host.new_stream(relay_peer_id, [SIGNALING_PROTOCOL])
         logger.info("Established signaling stream through circuit relay")
 
         # Create RTCPeerConnection and data channel using safe operations
@@ -143,13 +155,15 @@ def on_data_channel_error(error: Any) -> None:
         connection_failed = trio.Event()
 
         def on_connection_state_change() -> None:
-            state = peer_connection.connectionState
-            logger.debug(f"Connection state: {state}")
-            if state == "failed":
-                connection_failed.set()
+            if peer_connection is not None:
+                state = peer_connection.connectionState
+                logger.debug(f"Connection state: {state}")
+                if state == "failed":
+                    connection_failed.set()
 
         # Register connection state handler
-        peer_connection.on("connectionstatechange", on_connection_state_change)
+        if peer_connection is not None:
+            peer_connection.on("connectionstatechange", on_connection_state_change)
 
         # Wait for either success or failure
         with trio.move_on_after(timeout) as cancel_scope: