quinkgl 0.1.2__tar.gz → 0.1.16__tar.gz

{quinkgl-0.1.2/src/quinkgl.egg-info → quinkgl-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quinkgl
-Version: 0.1.2
+Version: 0.1.16
 Summary: A decentralized gossip learning framework for P2P edge intelligence
 Author-email: Ali Seyhan <aliseyhan@posta.mu.edu.tr>, Baki Turhan <bakiturhan@posta.mu.edu.tr>
 Project-URL: Homepage, https://github.com/aliseyhann/QuinkGL-Gossip-Learning-Framework

{quinkgl-0.1.2 → quinkgl-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quinkgl"
-version = "0.1.2"
+version = "0.1.16"
 description = "A decentralized gossip learning framework for P2P edge intelligence"
 readme = "README.md"
 authors = [

{quinkgl-0.1.2 → quinkgl-0.1.16}/src/quinkgl/network/gossip_community.py

@@ -8,6 +8,7 @@ CHUNKED TRANSFER: Large model updates are split into chunks
 to work around UDP MTU limits (~1400 bytes).
 """
 
+import asyncio
 import time
 import logging
 import hashlib
@@ -30,7 +31,7 @@ MAX_INCOMING_MESSAGE_SIZE = 150 * 1024 * 1024
 # Chunk size for large model transfers
 # Using 60KB which is below UDP's 65507 byte limit but reduces packet count significantly
 # A 5.8MB model = ~100 chunks instead of ~5800 chunks
-CHUNK_SIZE = 60000
+CHUNK_SIZE = 10000  # 10KB chunks - smaller for better NAT traversal
 
 # Timeout for incomplete transfers (300 seconds - increased for Colab/slow networks)
 CHUNK_TRANSFER_TIMEOUT = 300
@@ -521,6 +522,7 @@ class GossipLearningCommunity(Community):
                 model_version=payload.model_version
             )
             self.known_peers[payload.node_id] = peer_info
+            print(f"      🔗 Peer adresi: {payload.node_id} @ {peer.address}")
             logger.info(f"✅ Discovered compatible peer: {payload.node_id}")
 
             if self.on_peer_discovered_callback:
@@ -590,22 +592,27 @@ class GossipLearningCommunity(Community):
         
         Buffers chunks and triggers model processing when all chunks are received.
         """
-        transfer_id = payload.transfer_id
+        print(f"   [DEBUG] on_model_chunk called: chunk {payload.chunk_index}/{payload.total_chunks}")
+        transfer_id = f"{payload.sender_id}:{payload.round_number}"  # Use sender:round as key
         
-        # Log chunk receipt (only log first, last, and every 100th chunk to reduce noise)
+        # Log chunk receipt with visible print statements
         if payload.chunk_index == 0:
+            print(f"   📥 Chunk alımı başladı: {payload.sender_id} ({payload.total_chunks} chunk)")
             logger.info(
                 f"[NET] Receiving chunked model from {payload.sender_id} "
                 f"(transfer={transfer_id[:8]}..., chunks={payload.total_chunks}, "
                 f"round={payload.round_number})"
             )
-        elif payload.chunk_index == payload.total_chunks - 1:
+        elif (payload.chunk_index + 1) % 50 == 0 or payload.chunk_index == payload.total_chunks - 1:
+            progress = (payload.chunk_index + 1) / payload.total_chunks * 100
+            print(f"      📥 Alındı: {payload.chunk_index + 1}/{payload.total_chunks} ({progress:.0f}%)")
+        
+        if payload.chunk_index == payload.total_chunks - 1:
             logger.info(f"[NET] Received final chunk {payload.chunk_index + 1}/{payload.total_chunks} from {payload.sender_id}")
-        elif payload.chunk_index % 100 == 0:
-            logger.debug(f"[NET] Chunk progress: {payload.chunk_index + 1}/{payload.total_chunks} from {payload.sender_id}")
         
         # Create or get buffer for this transfer
         if transfer_id not in self._chunk_buffers:
+            print(f"   🆕 Yeni buffer oluşturuldu: {transfer_id[:8]}... (chunk {payload.chunk_index})")
             self._chunk_buffers[transfer_id] = ChunkBuffer(
                 transfer_id=transfer_id,
                 sender_id=payload.sender_id,
@@ -625,6 +632,14 @@ class GossipLearningCommunity(Community):
         # Update peer last seen
         if payload.sender_id in self.known_peers:
             self.known_peers[payload.sender_id].update_seen()
+            
+            # NAT keepalive: Send heartbeat every 5 chunks to keep NAT hole open
+            if payload.chunk_index % 5 == 0:
+                peer_info = self.known_peers[payload.sender_id]
+                self.ez_send(peer_info.peer, HeartbeatPayload(
+                    self.node_id,
+                    self._heartbeat_sequence
+                ))
         
         # If all chunks received, reassemble and process
         if is_complete:
@@ -658,21 +673,38 @@ class GossipLearningCommunity(Community):
                 
                 # Call callback
                 if self.on_model_update_callback:
-                    await self.on_model_update_callback(
-                        sender_id=payload.sender_id,
-                        weights=weights,
-                        sample_count=buffer.sample_count,
-                        round_number=buffer.round_number,
-                        loss=buffer.loss,
-                        accuracy=buffer.accuracy
-                    )
+                    print(f"   ✅ Model reassemble tamamlandı, callback çağrılıyor...")
+                    try:
+                        await self.on_model_update_callback(
+                            sender_id=payload.sender_id,
+                            weights=weights,
+                            sample_count=buffer.sample_count,
+                            round_number=buffer.round_number,
+                            loss=buffer.loss,
+                            accuracy=buffer.accuracy
+                        )
+                        print(f"   ✅ Callback başarılı!")
+                    except Exception as cb_err:
+                        print(f"   ❌ Callback hatası: {cb_err}")
+                        import traceback
+                        traceback.print_exc()
+                else:
+                    print(f"   ⚠️ Callback yok!")
                     
             except Exception as e:
                 logger.error(f"Failed to reassemble/process chunked model from {payload.sender_id}: {e}")
                 if transfer_id in self._chunk_buffers:
                     del self._chunk_buffers[transfer_id]
-
-    def send_model_update(
+        else:
+            # Debug: if this is the final chunk but buffer is not complete, log missing chunks
+            if payload.chunk_index == payload.total_chunks - 1:
+                actual_chunks = len(buffer.chunks)
+                print(f"   ⚠️ DEBUG: Son chunk alındı ama buffer complete değil!")
+                print(f"      Buffer: {actual_chunks}/{buffer.total_chunks} chunks")
+                missing = [i for i in range(buffer.total_chunks) if i not in buffer.chunks][:10]
+                print(f"      Eksik chunk indexleri: {missing}...")
+
+    async def send_model_update(
         self,
         target_node_id: str,
         weights: Any,
@@ -731,6 +763,9 @@ class GossipLearningCommunity(Community):
                 transfer_id = str(uuid.uuid4())
                 total_chunks = (len(weights_bytes) + CHUNK_SIZE - 1) // CHUNK_SIZE
                 
+                # Debug: show target peer address
+                print(f"      🎯 Target: {target_node_id} @ {peer_info.peer.address}")
+                
                 logger.info(
                     f"[NET] Sending chunked model to {target_node_id} "
                     f"(transfer={transfer_id[:8]}..., size={len(weights_bytes)} bytes, chunks={total_chunks})"
@@ -756,10 +791,15 @@ class GossipLearningCommunity(Community):
                     
                     self.ez_send(peer_info.peer, chunk_payload)
                     
-                    # Rate limiting: 5ms delay between chunks to prevent UDP buffer overflow
-                    # 98 chunks * 5ms = ~500ms per transfer, acceptable for model updates
+                    # Progress logging every 50 chunks (with 10KB chunks, we have ~230 chunks)
+                    if (i + 1) % 50 == 0 or i == total_chunks - 1:
+                        progress = (i + 1) / total_chunks * 100
+                        print(f"      📦 Chunk {i + 1}/{total_chunks} ({progress:.0f}%)")
+                    
+                    # Rate limiting: 200ms delay between chunks
+                    # Using asyncio.sleep so event loop can process incoming packets
                     if i < total_chunks - 1:  # Don't sleep after the last chunk
-                        time.sleep(0.005)
+                        await asyncio.sleep(0.2)
                 
                 logger.info(f"[NET] Sent {total_chunks} chunks to {target_node_id}")
             

{quinkgl-0.1.2 → quinkgl-0.1.16/src/quinkgl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quinkgl
-Version: 0.1.2
+Version: 0.1.16
 Summary: A decentralized gossip learning framework for P2P edge intelligence
 Author-email: Ali Seyhan <aliseyhan@posta.mu.edu.tr>, Baki Turhan <bakiturhan@posta.mu.edu.tr>
 Project-URL: Homepage, https://github.com/aliseyhann/QuinkGL-Gossip-Learning-Framework