PyObjC Framework MultipeerConnectivity

import MultipeerConnectivity

from MultipeerConnectivity import (
    MCPeerID, MCSession, MCNearbyServiceAdvertiser, MCNearbyServiceBrowser,
    MCAdvertiserAssistant, MCBrowserViewController
)

import MultipeerConnectivity
from Foundation import NSData, NSString

# Create a peer ID to identify this device
peer_id = MultipeerConnectivity.MCPeerID.alloc().initWithDisplayName_("MyDevice")

# Create a session for peer-to-peer communication
session = MultipeerConnectivity.MCSession.alloc().initWithPeer_(peer_id)

# Start advertising this device as available for connection
service_type = "my-app-service"
advertiser = MultipeerConnectivity.MCNearbyServiceAdvertiser.alloc().initWithPeer_discoveryInfo_serviceType_(
    peer_id, None, service_type
)

# Start browsing for other peers
browser = MultipeerConnectivity.MCNearbyServiceBrowser.alloc().initWithPeer_serviceType_(
    peer_id, service_type
)

# Send data to connected peers
message = "Hello from Python!"
data = message.encode('utf-8')
nsdata = NSData.alloc().initWithBytes_length_(data, len(data))

connected_peers = session.connectedPeers()
if connected_peers:
    success = session.sendData_toPeers_withMode_error_(
        nsdata, 
        connected_peers, 
        MultipeerConnectivity.MCSessionSendDataReliable,
        None
    )

class MCPeerID:
    def initWithDisplayName_(self, displayName: str) -> MCPeerID: ...
    def displayName(self) -> str: ...
    def hash(self) -> int: ...
    def isEqual_(self, object: object) -> bool: ...

class MCSession:
    def initWithPeer_(self, myPeerID: MCPeerID) -> MCSession: ...
    def initWithPeer_securityIdentity_encryptionPreference_(
        self, myPeerID: MCPeerID, 
        identity: object, 
        encryptionPreference: int
    ) -> MCSession: ...
    
    def sendData_toPeers_withMode_error_(
        self, data: NSData, 
        peerIDs: list, 
        mode: int, 
        error: object
    ) -> bool: ...
    
    def disconnect(self) -> None: ...
    def connectedPeers(self) -> list: ...
    def myPeerID(self) -> MCPeerID: ...
    
    def sendResourceAtURL_withName_toPeer_withCompletionHandler_(
        self, resourceURL: NSURL,
        resourceName: str,
        peerID: MCPeerID, 
        completionHandler: callable
    ) -> object: ...
    
    def startStreamWithName_toPeer_error_(
        self, streamName: str,
        peerID: MCPeerID,
        error: object
    ) -> NSOutputStream: ...
    
    def nearbyConnectionDataForPeer_withCompletionHandler_(
        self, peerID: MCPeerID,
        completionHandler: callable
    ) -> None: ...

class MCNearbyServiceAdvertiser:
    def initWithPeer_discoveryInfo_serviceType_(
        self, myPeerID: MCPeerID,
        info: dict,
        serviceType: str
    ) -> MCNearbyServiceAdvertiser: ...
    
    def startAdvertisingPeer(self) -> None: ...
    def stopAdvertisingPeer(self) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def myPeerID(self) -> MCPeerID: ...
    def discoveryInfo(self) -> dict: ...
    def serviceType(self) -> str: ...

class MCNearbyServiceBrowser:
    def initWithPeer_serviceType_(
        self, myPeerID: MCPeerID,
        serviceType: str
    ) -> MCNearbyServiceBrowser: ...
    
    def startBrowsingForPeers(self) -> None: ...
    def stopBrowsingForPeers(self) -> None: ...
    def invitePeer_toSession_withContext_timeout_(
        self, peerID: MCPeerID,
        session: MCSession,
        context: NSData,
        timeout: float
    ) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def myPeerID(self) -> MCPeerID: ...
    def serviceType(self) -> str: ...

class MCAdvertiserAssistant:
    def initWithServiceType_discoveryInfo_session_(
        self, serviceType: str,
        info: dict,
        session: MCSession
    ) -> MCAdvertiserAssistant: ...
    
    def start(self) -> None: ...
    def stop(self) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def session(self) -> MCSession: ...
    def discoveryInfo(self) -> dict: ...
    def serviceType(self) -> str: ...

class MCBrowserViewController:
    def initWithServiceType_session_(
        self, serviceType: str,
        session: MCSession
    ) -> MCBrowserViewController: ...
    
    def initWithBrowser_session_(
        self, browser: MCNearbyServiceBrowser,
        session: MCSession
    ) -> MCBrowserViewController: ...
    
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def browser(self) -> MCNearbyServiceBrowser: ...
    def session(self) -> MCSession: ...
    def minimumNumberOfPeers(self) -> int: ...
    def setMinimumNumberOfPeers_(self, minimumNumberOfPeers: int) -> None: ...
    def maximumNumberOfPeers(self) -> int: ...
    def setMaximumNumberOfPeers_(self, maximumNumberOfPeers: int) -> None: ...

MCSessionSendDataReliable: int = 0     # Guaranteed delivery, ordered
MCSessionSendDataUnreliable: int = 1   # Best effort delivery, unordered

MCSessionStateNotConnected: int = 0    # Peer is not connected
MCSessionStateConnecting: int = 1      # Peer is connecting
MCSessionStateConnected: int = 2       # Peer is connected

MCEncryptionOptional: int = 0          # Encryption preferred but not required
MCEncryptionRequired: int = 1          # Encryption required for connection
MCEncryptionNone: int = 2              # No encryption

kMCSessionMinimumNumberOfPeers: int    # Minimum peers in session (typically 1)
kMCSessionMaximumNumberOfPeers: int    # Maximum peers in session (typically 8)

MCErrorDomain: str                     # Error domain identifier

MCErrorUnknown: int = 0                # Unknown error
MCErrorNotConnected: int = 1           # Peer not connected
MCErrorInvalidParameter: int = 2       # Invalid parameter passed
MCErrorUnsupported: int = 3            # Operation not supported
MCErrorTimedOut: int = 4               # Operation timed out
MCErrorCancelled: int = 5              # Operation was cancelled
MCErrorUnavailable: int = 6            # Service unavailable

# Required methods
def session_peer_didChangeState_(self, session: MCSession, peerID: MCPeerID, state: int) -> None:
    """Called when a peer changes connection state"""

def session_didReceiveData_fromPeer_(self, session: MCSession, data: NSData, peerID: MCPeerID) -> None:
    """Called when data is received from a peer"""

def session_didReceiveStream_withName_fromPeer_(
    self, session: MCSession, stream: NSInputStream, streamName: str, peerID: MCPeerID
) -> None:
    """Called when a stream is received from a peer"""

def session_didStartReceivingResourceWithName_fromPeer_withProgress_(
    self, session: MCSession, resourceName: str, peerID: MCPeerID, progress: NSProgress
) -> None:
    """Called when starting to receive a resource from a peer"""

def session_didFinishReceivingResourceWithName_fromPeer_atURL_withError_(
    self, session: MCSession, resourceName: str, peerID: MCPeerID, localURL: NSURL, error: NSError
) -> None:
    """Called when finished receiving a resource from a peer"""

# Optional methods
def session_didReceiveCertificate_fromPeer_certificateHandler_(
    self, session: MCSession, certificate: NSArray, peerID: MCPeerID, certificateHandler: callable
) -> None:
    """Called to validate peer certificate for secure connections"""

# Required method
def advertiser_didReceiveInvitationFromPeer_withContext_invitationHandler_(
    self, advertiser: MCNearbyServiceAdvertiser, 
    peerID: MCPeerID, 
    context: NSData, 
    invitationHandler: callable
) -> None:
    """Called when receiving an invitation from a peer"""

# Optional method
def advertiser_didNotStartAdvertisingPeer_(
    self, advertiser: MCNearbyServiceAdvertiser, 
    error: NSError
) -> None:
    """Called when advertising fails to start"""

# Required methods
def browser_foundPeer_withDiscoveryInfo_(
    self, browser: MCNearbyServiceBrowser, 
    peerID: MCPeerID, 
    info: dict
) -> None:
    """Called when a peer is discovered"""

def browser_lostPeer_(
    self, browser: MCNearbyServiceBrowser, 
    peerID: MCPeerID
) -> None:
    """Called when a peer is lost"""

# Optional method
def browser_didNotStartBrowsingForPeers_(
    self, browser: MCNearbyServiceBrowser, 
    error: NSError
) -> None:
    """Called when browsing fails to start"""

# Required methods
def browserViewControllerDidFinish_(self, browserViewController: MCBrowserViewController) -> None:
    """Called when user finishes with browser"""

def browserViewControllerWasCancelled_(self, browserViewController: MCBrowserViewController) -> None:
    """Called when user cancels browser"""

# Optional method
def browserViewController_shouldPresentNearbyPeer_withDiscoveryInfo_(
    self, browserViewController: MCBrowserViewController,
    peerID: MCPeerID,
    info: dict
) -> bool:
    """Called to determine if peer should be shown in browser"""

# Optional methods
def advertiserAssistantWillPresentInvitation_(
    self, advertiserAssistant: MCAdvertiserAssistant
) -> None:
    """Called before presenting invitation dialog"""

def advertiserAssistantDidDismissInvitation_(
    self, advertiserAssistant: MCAdvertiserAssistant  
) -> None:
    """Called after dismissing invitation dialog"""

NSData = object          # Binary data container
NSString = object        # String object  
NSURL = object           # URL reference
NSInputStream = object   # Input stream
NSOutputStream = object  # Output stream
NSProgress = object      # Progress reporting
NSError = object         # Error information
NSArray = object         # Array container