Peer-to-Peer Network

class SyftboxPlatformConnection(BaseModel):
    """Base interface for all transport layers"""
    
    def send_proposed_file_changes_message(
        self, proposed_file_change_message: ProposedFileChangesMessage
    ):
        """Send a message to peer's inbox"""
        raise NotImplementedError()
    
    def create_dataset_collection_folder(
        self, tag: str, content_hash: str, owner_email: str
    ) -> str:
        """Create a shared dataset collection"""
        raise NotImplementedError()
    
    def share_dataset_collection(
        self, tag: str, content_hash: str, users: list[str]
    ) -> None:
        """Share dataset with specific users"""
        raise NotImplementedError()

class ConnectionRouter:
    """Routes messages to appropriate transport layers"""
    
    def __init__(self, connections: List[SyftboxPlatformConnection]):
        self.connections = connections
    
    @classmethod
    def from_configs(cls, connection_configs: List[ConnectionConfig]):
        """Create router from configuration"""
        connections = [
            config.connection_type.from_config(config) 
            for config in connection_configs
        ]
        return cls(connections=connections)
    
    def send_proposed_file_changes_message(
        self, recipient: str, message: ProposedFileChangesMessage
    ):
        """Send message via first available connection"""
        self.connections[0].send_proposed_file_changes_message(message)
    
    def get_next_proposed_filechange_message(
        self, sender_email: str
    ) -> ProposedFileChangesMessage | None:
        """Pull next message from inbox"""
        return self.connections[0].get_next_proposed_filechange_message(sender_email)

class PeerState(str, Enum):
    ACCEPTED = "accepted"      # Peer connection approved
    PENDING = "pending"        # Awaiting approval from peer
    REJECTED = "rejected"      # Connection rejected
    OUTSTANDING = "outstanding"  # Outgoing request sent

class Peer(BaseModel):
    email: str
    platforms: List[BasePlatform] = []  # Available transport layers
    state: PeerState = PeerState.ACCEPTED
    version: Optional[VersionInfo] = None
    
    @property
    def is_approved(self) -> bool:
        return self.state == PeerState.ACCEPTED

class FileChangeEventsMessage(BaseModel):
    events: List[FileChangeEvent]
    
    @property
    def message_filepath(self) -> FileChangeEventsMessageFileName:
        """Generate unique filename for this message"""
        return FileChangeEventsMessageFileName(
            id=uuid4(),
            timestamp=create_event_timestamp()
        )
        # Returns: syfteventsmessagev3_{timestamp}_{uuid}.tar.gz