dayanara 0.1.3__tar.gz

dayanara-0.1.3/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Olaf Pedersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dayanara-0.1.3/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: dayanara
+Version: 0.1.3
+Summary: A lightweight peer-to-peer networking protocol implementation in Python with bootstrap server support for peer discovery and room-based connections.
+Author: Olaf Pedersen
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+
+# Dayanara
+
+Dayanara is a lightweight peer-to-peer networking library for Python that allows
+peers to discover each other using bootstrap servers and communicate inside rooms.
+
+## Installation
+
+```bash
+pip install dayanara
+````
+
+## Basic usage
+
+```python
+from dayanara import Dayanara
+
+d = Dayanara()
+d.join("room1")
+
+d.send("Hola")
+msg = d.receive()
+print(msg)
+```
+
+## API
+
+### Dayanara
+
+#### Dayanara(bootstraps=None, debug=False)
+
+Create a new Dayanara instance.
+
+* `bootstraps`: list of bootstrap servers (optional)
+* `debug`: enable debug output (default: False)
+
+#### join(room: str)
+
+Join a room and start peer discovery.
+
+#### send(data)
+
+Send data to all connected peers.
+
+#### receive()
+
+Block until a message is received and return it.
+
+#### peers_list()
+
+Return the list of known peers.
+
+## License
+
+MIT

dayanara-0.1.3/README.md

@@ -0,0 +1,55 @@
+
+# Dayanara
+
+Dayanara is a lightweight peer-to-peer networking library for Python that allows
+peers to discover each other using bootstrap servers and communicate inside rooms.
+
+## Installation
+
+```bash
+pip install dayanara
+````
+
+## Basic usage
+
+```python
+from dayanara import Dayanara
+
+d = Dayanara()
+d.join("room1")
+
+d.send("Hola")
+msg = d.receive()
+print(msg)
+```
+
+## API
+
+### Dayanara
+
+#### Dayanara(bootstraps=None, debug=False)
+
+Create a new Dayanara instance.
+
+* `bootstraps`: list of bootstrap servers (optional)
+* `debug`: enable debug output (default: False)
+
+#### join(room: str)
+
+Join a room and start peer discovery.
+
+#### send(data)
+
+Send data to all connected peers.
+
+#### receive()
+
+Block until a message is received and return it.
+
+#### peers_list()
+
+Return the list of known peers.
+
+## License
+
+MIT

dayanara-0.1.3/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dayanara"
+version = "0.1.3"
+description = "A lightweight peer-to-peer networking protocol implementation in Python with bootstrap server support for peer discovery and room-based connections."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+
+authors = [
+  { name = "Olaf Pedersen" }
+]
+
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]

dayanara-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dayanara-0.1.3/src/dayanara/__init__.py

@@ -0,0 +1,3 @@
+from .main import Dayanara
+
+__all__ = ["Dayanara"]

dayanara-0.1.3/src/dayanara/core.py

@@ -0,0 +1,154 @@
+from .peer import Peer
+from .olaf import Olaf
+from .network import Network
+from .msg_types import *
+import queue
+import time
+import sys
+import socket
+
+class Core:
+    def __init__(self, bootstraps, debug):
+        self.bootstraps = bootstraps
+        self.app_queue = queue.Queue()
+        self.network_queue = queue.Queue()
+        self.network = Network(bootstraps=bootstraps)
+        self.binary = Olaf()        
+        self.peer = Peer()
+        self.b_count = 0
+        self.debug = debug
+
+    def connect(self):
+        """Thread que recibe mensajes"""
+        while True:
+            try:
+                message, addr = self.peer.socket_receive()
+                msg_type = message[0]
+                if self.debug: print(f"Mensaje recibido: {message}")
+                
+                if msg_type == APP_R: 
+                    self.app_queue.put((message, addr))
+
+                elif msg_type == BOOTSTRAP_R: 
+                    self.bootstrap_res(message, addr)
+
+                elif msg_type == PING: 
+                    self.ping_res(message, addr)
+
+                elif msg_type == ROOM_FULL: # falta implementar logica de room full
+                    self.room_full(message, addr)
+
+                else: continue
+            
+            except socket.timeout:
+                # Ignorar timeouts silenciosamente
+                continue
+            except Exception as e:
+                # agregar logging luego
+                continue
+
+    def heart(self, room):
+        while True:
+            self.network.evaluate_state()
+            if self.debug: print(self.network.get_state())
+
+            if self.network.send_ping: 
+                if self.debug: print('enviando ping')
+                self.peer.socket_send_all(
+                    type=PING, 
+                    peers=self.network.get_other_peers(), 
+                    payload=''
+                )
+
+            if self.network.purge: 
+                if self.debug: print('purgando')
+                self.network.delete_inactive()
+
+            if self.network.send_collector:
+                if self.debug: print('enviando collector')
+                target = self.network.bootstraps[self.b_count]
+                self.peer.socket_send(
+                    type=PEER_COLLECTOR,
+                    payload=room, 
+                    target_addr=target
+                )
+
+            if self.network.send_join:
+                if self.debug: print('enviando join')
+                peers = []
+                if self.network.self_addr != None:
+                    peers = [self.network.self_addr]
+                target = self.network.bootstraps[self.b_count]
+                self.peer.socket_send(
+                    type=JOIN_B, 
+                    peers=peers,
+                    payload=room,
+                    target_addr=target
+                )
+            time.sleep(3)
+
+    def app_send(self, data):
+        if data is None:
+            raise ValueError("Data is required")
+        self.peer.socket_send_all(type=APP_R, peers=self.network.get_other_peers(), payload=data)
+
+    def app_receive(self):
+        message, addr = self.app_queue.get()
+        if message is None:
+            return ''
+        msg_type, peers, payload = message
+        return payload
+
+    def signal_handler(self, sig, frame):
+        try:
+            self.peer.socket_send_all(type=PING, peers=self.network.get_other_peers(), payload='bye')
+        except Exception as e:
+            print(f"Error al enviar despedida: {e}")
+        
+        self.peer.socket_close()
+        sys.exit(0)
+
+    def bootstrap_res(self, message, addr):
+        _ , peers, payload = message
+        
+        # revisar si se codifica bien el payload
+        if self.network.self_addr is None:
+            self.network.add_self_addr(payload)
+
+        for peer in peers:
+            self.network.add_peer(peer)
+
+
+    def ping_res(self, message, addr):
+        msg_type, peers, payload = message
+
+        if payload == b'bye':
+            peer_to_remove = None
+            for peer in self.network.get_peers_list():
+                if peer[0] == addr[0] and peer[1] == addr[1]:
+                    peer_to_remove = peer
+                    break
+            
+            if peer_to_remove:
+                self.network.remove_peer(peer_to_remove)
+                if self.debug: print(f"Peer {peer_to_remove[2]} removido")
+        else:
+            # ✅ PRIMERO: Actualizar timestamp del peer que ENVIÓ el mensaje
+            sender_peer = None
+            for peer in self.network.get_peers_list():
+                if peer[0] == addr[0] and peer[1] == addr[1]:
+                    sender_peer = peer
+                    break
+            
+            if sender_peer:
+                self.network.update_ts(sender_peer)
+            
+            # ✅ SEGUNDO: Agregar/actualizar peers de la lista
+            for peer in peers:
+                self.network.add_peer(peer)
+                self.network.update_ts(peer)
+
+    def room_full(self, message, addr):
+        if self.debug: print(message)
+
+

dayanara-0.1.3/src/dayanara/main.py

@@ -0,0 +1,32 @@
+from .core import Core
+import signal
+import threading
+import time
+
+class Dayanara(Core):
+    def __init__(self, bootstraps=[['127.0.0.1', 5000], ['127.0.0.1', 5001]], debug=False):
+        super().__init__(bootstraps, debug)
+
+    def join(self, room):
+        # ✅ Mover signal handler aquí (se ejecuta en thread principal)
+        # signal.signal(signal.SIGINT, self.signal_handler)
+        
+        threading.Thread(target=self.connect, daemon=True).start()
+        threading.Thread(target=self.heart, args=(room,), daemon=True).start()
+
+        # # Mantener el programa vivo
+        # try:
+        #     while True:
+        #         time.sleep(1)
+        # except KeyboardInterrupt:
+        #     print("Cerrando...")
+
+
+    def send(self, data):
+        self.app_send(data)
+
+    def receive(self):
+        return self.app_receive()
+    
+    def peers_list(self):
+        return self.network.get_peers_list()

dayanara-0.1.3/src/dayanara/msg_types.py

@@ -0,0 +1,6 @@
+PING = 0
+JOIN_B = 1
+BOOTSTRAP_R = 2
+APP_R = 3
+ROOM_FULL = 4
+PEER_COLLECTOR = 5

dayanara-0.1.3/src/dayanara/network.py

@@ -0,0 +1,152 @@
+import time
+import queue
+import threading
+
+class State:
+    def __init__(self):
+        self.send_join = True
+        self.send_collector = False
+        self.send_ping = False
+        self.purge = False
+
+class Network(State):
+    def __init__(self, timeout=15, ip='0.0.0.0', port=0, bootstraps=None):
+        super().__init__()
+        self.self_addr = None
+        self.bootstraps = bootstraps # lista de boostraps publicos activos
+
+        # Registro de nodos
+        self.peers_in_room = []
+        self.peers_life = {}
+
+        self.write_queue = queue.Queue()
+        self.timeout = timeout
+
+        self._writer_thread = threading.Thread(
+            target=self.write_thread,
+            daemon=True
+        ).start()
+
+# ------------------------------------------------threading pipeline------------------------------------------
+    def write_thread(self):
+        while True:
+            
+            cmd, peer = self.write_queue.get()
+
+            if cmd == 'add_self_addr':
+                self.self_addr = peer
+                if peer not in self.peers_in_room:
+                    self.peers_in_room.append(peer)
+                    self.peers_life[peer[2]] = time.time()
+
+            elif cmd == 'add_peer':
+                if peer not in self.peers_in_room:
+                    self.peers_in_room.append(peer)
+                    self.peers_life[peer[2]] = time.time()
+
+            elif cmd == 'remove_peer':
+                if peer in self.peers_in_room:
+                    self.peers_in_room.remove(peer)
+                    del self.peers_life[peer[2]]
+
+            elif cmd == 'delete_inactive':
+                current_time = time.time()
+                
+                for peer_id, last_seen in list(self.peers_life.items()):
+                    if current_time - last_seen > self.timeout:
+                        # Buscar el peer completo por su ID
+                        peer_addr = next((peer for peer in self.peers_in_room if peer[2] == peer_id), None)
+                        if peer_addr:
+                            self.peers_in_room.remove(peer_addr)
+                            del self.peers_life[peer_addr[2]]
+
+            elif cmd == 'update_ts':
+                if peer and peer[2] in self.peers_life:
+                    self.peers_life[peer[2]] = time.time()
+
+            else: continue # ignora silenciosamente
+
+# ---------------------------------------------------WRITE-------------------------------------------------
+
+    def add_self_addr(self, public_addr: list) -> None:
+        self.write_queue.put(('add_self_addr', public_addr))
+
+    def add_peer(self, peer_addr: list) -> None:
+        self.write_queue.put(('add_peer', peer_addr))
+        
+    def remove_peer(self, peer_addr: list) -> None:
+        self.write_queue.put(('remove_peer', peer_addr))
+
+    def delete_inactive(self) -> None:
+        self.write_queue.put(('delete_inactive', None))
+
+    def update_ts(self, peer_addr: list) -> None:
+        self.write_queue.put(('update_ts', peer_addr))
+
+# ---------------------------------------------- READ-------------------------------------------------------
+
+    def get_peers_list(self) -> list: # Read
+        ''' get the list of peers in the room: return [peer1,peer2,peer3,...]'''
+        return self.peers_in_room.copy()
+
+    def get_other_peers(self) -> list: # Read
+        ''' get the list of other peers in the room'''
+        p_i_r_copy = self.peers_in_room.copy()
+
+        if self.self_addr is None:
+            return []
+        return [peer for peer in p_i_r_copy if peer[:2] != self.self_addr[:2]]
+
+    def min_id(self) -> bool: # Read
+        ''' check if self_addr has the minimum id'''
+        p_i_r_copy = self.peers_in_room.copy()
+ 
+        if not p_i_r_copy:
+            return False
+        min_id = min(peer[2] for peer in p_i_r_copy)
+        return self.self_addr[2] == min_id
+
+
+# ---------------------------------------------STATUS-----------------------------------------------
+    def evaluate_state(self) -> None:
+        p_i_r_copy = self.peers_in_room.copy()
+        # Calcular others directamente sin llamar a get_other_peers() para evitar deadlock
+        if self.self_addr is None:
+            others = []
+        else:
+            others = [peer for peer in p_i_r_copy if peer[:2] != self.self_addr[:2]]
+        has_others = len(others) > 0  # ✅ Criterio correcto
+            
+        # Si hay OTROS peers (no solo yo)
+        if has_others:
+            self.purge = True
+            self.send_ping = True
+            self.send_join = False
+                
+            # Solo si soy el peer con menor ID, enviar COLLECTOR al bootstrap
+            # Calcular min_id directamente sin llamar al método para evitar deadlock
+            if not p_i_r_copy or self.self_addr is None:
+                is_min_id = False
+            else:
+                min_id = min(peer[2] for peer in p_i_r_copy)
+                is_min_id = self.self_addr[2] == min_id
+                
+            if is_min_id:
+                self.send_collector = True
+            else:
+                self.send_collector = False
+            
+        # Si estoy solo
+        else:
+            self.send_join = True
+            self.send_ping = False
+            self.send_collector = False
+            self.purge = False
+                
+    def get_state(self) -> dict:
+        return { 
+            'send_collector': self.send_collector, 
+            'send_join': self.send_join, 
+            'send_ping': self.send_ping, 
+            'purge': self.purge 
+            }

dayanara-0.1.3/src/dayanara/olaf.py

@@ -0,0 +1,95 @@
+import struct
+import socket
+from .msg_types import *
+
+class Olaf:
+    """
+    Protocolo Olaf (orden de bytes):
+    [type (1B)] [peers (num_peers 2B + N*peer)] [payload (len 4B + data)]
+    peer = [IPv4 (4B) + port (2B) + id (4B)] = 10 bytes total
+
+    Convención de direcciones en esta API: listas
+    - peers_addr: [[ip:str, port:int, id:int], ...]
+    """
+#--------------------------------------pack------------------------------------------------
+    @staticmethod
+    def pack_addr(addr) -> bytes:
+        ip, port, peer_id = addr or ['0.0.0.0', 0, 0]
+        return struct.pack("!4sHI", socket.inet_aton(ip), int(port), int(peer_id))  # 10B
+
+    @staticmethod
+    def pack_peers(peers_addr) -> bytes:
+        peers = peers_addr or []
+        body = b"".join(Olaf.pack_addr(peer) for peer in peers)
+        return struct.pack("!H", len(peers)) + body  # [num_peers][peers...]
+
+    @staticmethod
+    def pack_payload(payload) -> bytes:
+        if isinstance(payload, str):
+            payload = payload.encode("utf-8")
+        return struct.pack("!I", len(payload)) + payload  # [len][data]
+
+#--------------------------------------unpack------------------------------------------------
+    @staticmethod
+    def unpack_addr(data: bytes, offset: int):
+        ip = socket.inet_ntoa(data[offset:offset+4])
+        port = struct.unpack_from("!H", data, offset+4)[0]
+        peer_id = struct.unpack_from("!I", data, offset+6)[0]
+        return [ip, port, peer_id], offset + 10
+
+    @staticmethod
+    def unpack_peers(data: bytes, offset: int):
+        num_peers = struct.unpack_from("!H", data, offset)[0]
+        offset += 2
+        peers = []
+        for _ in range(num_peers):
+            addr, offset = Olaf.unpack_addr(data, offset)
+            peers.append(addr)
+        return peers, offset
+
+    @staticmethod
+    def unpack_payload(data: bytes, offset: int):
+        payload_len = struct.unpack_from("!I", data, offset)[0]
+        offset += 4
+        payload = data[offset:offset+payload_len]
+        return payload, offset + payload_len
+
+#--------------------------------------encode------------------------------------------------
+    @staticmethod
+    def encode_msg(msg_type: int, peers_addr: list, payload: bytes | str = b"") -> bytes:
+        """
+        Inputs:
+        - msg_type: int
+        - peers_addr: [["127.0.0.1", 12346, 1234567890], ["127.0.0.2", 12347, 1234567891]]
+        - payload: bytes o str (si es str se codifica utf-8)
+        """
+        # [type][peers][payload]
+        if msg_type == BOOTSTRAP_R:
+            payload = Olaf.pack_addr(payload)
+        else:
+            payload = Olaf.pack_payload(payload)
+            
+        type_block = struct.pack("!B", int(msg_type))                   # [type] (1B)
+        peers_block = Olaf.pack_peers(peers_addr)                       # [peers] ([2B]+N*8B)
+        payload_block = payload                                         # payload ya está empaquetado
+        return type_block + peers_block + payload_block
+
+#--------------------------------------decode------------------------------------------------
+    @staticmethod
+    def decode_msg(data: bytes):
+        """
+        Output (listas):
+        - msg_type: int
+        - peers: [["127.0.0.1", 12346, 1234567890], ["127.0.0.2", 12347, 1234567891]]
+        - payload: bytes
+        """
+        msg_type = struct.unpack_from("!B", data, 0)[0]
+        offset = 1  # Después del byte de tipo
+        peers, offset = Olaf.unpack_peers(data, offset)
+        if msg_type == BOOTSTRAP_R:
+            payload, offset = Olaf.unpack_addr(data, offset)
+            return msg_type, peers, payload
+        else:
+            payload, offset = Olaf.unpack_payload(data, offset)
+            return msg_type, peers, payload
+

dayanara-0.1.3/src/dayanara/peer.py

@@ -0,0 +1,28 @@
+import socket
+from .olaf import Olaf
+
+class Peer:
+    def __init__(self, ip='0.0.0.0', port=0):
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.bind((ip, port))
+        self.binary = Olaf()
+
+    def socket_send(self, type=None, peers=[], payload='', target_addr=None):
+        data = self.binary.encode_msg(type, peers, payload)
+        self.sock.sendto(data, (target_addr[0], target_addr[1]))
+
+    def socket_send_all(self, type=None, peers=[], payload=''):
+        for peer in peers:
+            self.socket_send(type=type, peers=peers, payload=payload, target_addr=peer)
+
+    def socket_receive(self, timeout=1.0, buffer_size=1024):
+        self.sock.settimeout(timeout) # evita que el socket se bloquee
+        try:
+            data, addr = self.sock.recvfrom(buffer_size)
+            return self.binary.decode_msg(data), [addr[0], addr[1]]
+        except socket.timeout:
+            raise  # Re-lanzar para que el caller sepa que hubo timeout
+
+    def socket_close(self):
+        self.sock.close()
+

dayanara-0.1.3/src/dayanara/test/test.dayanara.py

@@ -0,0 +1,38 @@
+import sys
+from pathlib import Path
+import threading
+
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from main import Dayanara
+
+# Setup
+username = input("Nombre: ")
+room = input("Sala: ")
+
+# Instanciar
+d = Dayanara()
+
+# Join async (NO bloquea)
+d.join(room)
+
+# Thread para recibir
+def recibir():
+    while True:
+        msg = d.receive()
+        if msg:
+            print(f"\r{msg}")
+            print(f"{username}: ", end='', flush=True)
+            print(d.conn_peers())
+
+threading.Thread(target=recibir, daemon=True).start()
+
+# Bucle para enviar
+try:
+    while True:
+        mensaje = input(f"{username}: ")
+        if mensaje:
+            d.send(f"{username}: {mensaje}")
+except KeyboardInterrupt:
+    print("\nCerrando...")
+    sys.exit(0)
+

dayanara-0.1.3/src/dayanara.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: dayanara
+Version: 0.1.3
+Summary: A lightweight peer-to-peer networking protocol implementation in Python with bootstrap server support for peer discovery and room-based connections.
+Author: Olaf Pedersen
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Dynamic: license-file
+
+
+# Dayanara
+
+Dayanara is a lightweight peer-to-peer networking library for Python that allows
+peers to discover each other using bootstrap servers and communicate inside rooms.
+
+## Installation
+
+```bash
+pip install dayanara
+````
+
+## Basic usage
+
+```python
+from dayanara import Dayanara
+
+d = Dayanara()
+d.join("room1")
+
+d.send("Hola")
+msg = d.receive()
+print(msg)
+```
+
+## API
+
+### Dayanara
+
+#### Dayanara(bootstraps=None, debug=False)
+
+Create a new Dayanara instance.
+
+* `bootstraps`: list of bootstrap servers (optional)
+* `debug`: enable debug output (default: False)
+
+#### join(room: str)
+
+Join a room and start peer discovery.
+
+#### send(data)
+
+Send data to all connected peers.
+
+#### receive()
+
+Block until a message is received and return it.
+
+#### peers_list()
+
+Return the list of known peers.
+
+## License
+
+MIT

dayanara-0.1.3/src/dayanara.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENCE
+README.md
+pyproject.toml
+src/dayanara/__init__.py
+src/dayanara/core.py
+src/dayanara/main.py
+src/dayanara/msg_types.py
+src/dayanara/network.py
+src/dayanara/olaf.py
+src/dayanara/peer.py
+src/dayanara.egg-info/PKG-INFO
+src/dayanara.egg-info/SOURCES.txt
+src/dayanara.egg-info/dependency_links.txt
+src/dayanara.egg-info/top_level.txt
+src/dayanara/test/test.dayanara.py
+src/dayanara/test/test.network.py
+src/dayanara/test/test.olaf.py
+src/dayanara/test/test.peer.py
+src/dayanara/test/test_core.py

dayanara-0.1.3/src/dayanara.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dayanara-0.1.3/src/dayanara.egg-info/top_level.txt

@@ -0,0 +1 @@
+dayanara