subnx 0.1.0__tar.gz

subnx-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: subnx
+Version: 0.1.0
+Summary: High-concurrency event-driven network framework and SDK
+Author-email: Humberto Manuel Cabrera <humbertomanuel_cabrera@outlook.es>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9.0

subnx-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "subnx"
+version = "0.1.0"
+authors = [
+    { name = "Humberto Manuel Cabrera", email = "humbertomanuel_cabrera@outlook.es" },
+]
+description = "High-concurrency event-driven network framework and SDK"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = ["psutil>=5.9.0"]
+
+
+[tool.setuptools.packages.find]
+include = ["subnx*"]
+exclude = ["examples*", "tests*"]

subnx-0.1.0/setup.cfg

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

subnx-0.1.0/subnx/__init__.py

@@ -0,0 +1,17 @@
+# orvanta/__init__.py
+
+from .models import Event, State, MessageState, ClientInformation, ClientHardwareResourcesStatistics
+from .events import GlobalEvents, EventRouter
+from .client import Client
+
+__version__ = "0.1.0"
+__all__ = [
+    "Client",
+    "GlobalEvents",
+    "Event",
+    "State",
+    "MessageState",
+    "ClientInformation",
+    "ClientHardwareResourcesStatistics",
+    "EventRouter"
+]

subnx-0.1.0/subnx/client.py

@@ -0,0 +1,202 @@
+# subnx/client.py
+import socket
+import ssl
+import json
+import struct
+import threading
+import time
+import random
+import queue
+import signal
+from typing import Any, Callable, Optional, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import Event, State
+
+class Client:
+    def __init__(self, host: str, port: str, client_name: str, api_key: str, use_tls: bool = False):
+        self.host = host
+        self.port = int(port)
+        self.name = client_name
+        self.api_key = api_key
+        self.use_tls = use_tls
+
+        self._mu = threading.RLock()       
+        self._write_mu = threading.Lock()  
+        self.conn: Optional[socket.socket] = None
+
+        self._closed = False
+        self._close_lock = threading.Lock() 
+        
+        self.is_ready = threading.Event()   
+        self.done = threading.Event()       
+        
+        self.attempt = 1
+        self.min_backoff = 1.0  
+        self.max_backoff = 30.0 
+
+        # 👈 NUEVO: Mapa seguro para procesos concurrentes (Equivalente a chan State)
+        self.pending_requests: Dict[str, queue.Queue] = {}
+        self.pending_requests_mu = threading.Lock()
+
+        threading.Thread(target=self._run, daemon=True).start()
+
+    def send(self, event: 'Event', timeout: float = 65.0, callback: Callable[['State'], None] = None) -> None:
+        with self._close_lock:
+            if self._closed:
+                raise Exception("client cerrado")
+
+        # 🌟 MAGIA DE CONCURRENCIA
+        ready = self.is_ready.wait(timeout=5.0)
+
+        with self._mu:
+            conn_active = self.conn is not None
+
+        if not ready or not conn_active:
+            raise Exception("conexión no está lista (handshake pendiente o servidor caído)")
+
+        return event.send_data(self, timeout, callback)
+
+    def set_ready(self):
+        self.is_ready.set()
+
+    def close(self) -> None:
+        with self._close_lock:
+            if self._closed:
+                return
+            self._closed = True
+            
+        self.done.set()
+
+        with self._mu:
+            if self.conn:
+                try:
+                    self.conn.close()
+                except:
+                    pass
+                self.conn = None
+
+    def get_conn(self) -> Optional[socket.socket]:
+        with self._mu:
+            return self.conn
+
+    def set_conn(self, conn: socket.socket):
+        with self._mu:
+            self.conn = conn
+
+    def clear_conn(self):
+        with self._mu:
+            if self.conn:
+                try:
+                    self.conn.close()
+                except:
+                    pass
+            self.conn = None
+            self.is_ready.clear() 
+
+    def _backoff(self) -> float:
+        base = self.min_backoff * (2 ** (self.attempt - 1))
+        if base > self.max_backoff:
+            base = self.max_backoff
+            
+        jitter = random.uniform(0, base / 5)
+        if random.choice([True, False]):
+            return base - jitter
+        return base + jitter
+
+    def _run(self):
+        from .protocol import read_loop
+
+        while not self._closed:
+            start_time = time.time()
+            
+            try:
+                raw_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                if self.use_tls:
+                    ctx = ssl.create_default_context()
+                    ctx.check_hostname = False
+                    ctx.verify_mode = ssl.CERT_NONE
+                    self.conn = ctx.wrap_socket(raw_sock, server_hostname=self.host)
+                else:
+                    self.conn = raw_sock
+
+                self.conn.connect((self.host, self.port))
+                
+            except Exception as e:
+                delay = self._backoff()
+                print(f"[client {self.name}] error al conectar: {e} (reintento en {delay:.2f}s)")
+                
+                if self.done.wait(timeout=delay):
+                    return
+                self.attempt += 1
+                continue
+
+            self.attempt = 1
+            handshake_latency = int((time.time() - start_time) * 1000)
+            print(f"[client {self.name}] conectado (latencia: {handshake_latency} ms)")
+
+            server_status = queue.Queue(maxsize=1)
+            
+            threading.Thread(target=read_loop, args=(self, server_status, float(handshake_latency)), daemon=True).start()
+
+            while not self.done.is_set():
+                try:
+                    status = server_status.get(timeout=0.5)
+                    if not status:
+                        print(f"[client {self.name}] desconectado por el servidor, reconectando...")
+                        self.clear_conn()
+                        break 
+                except queue.Empty:
+                    continue 
+
+            if self.done.is_set():
+                self.clear_conn()
+                return
+
+    def write_packet(self, msg_type: int, event_name: str, server_uid: str, obj_data: Any) -> None:
+        try:
+            data_bytes = json.dumps(obj_data).encode('utf-8')
+        except Exception as e:
+            raise Exception(f"error al serializar paquete: {e}")
+
+        event_name_bytes = event_name.encode('utf-8')
+        name_len = len(event_name_bytes)
+        uid_bytes = server_uid.encode('utf-8').ljust(36, b'\x00')[:36]
+        payload_size = len(data_bytes)
+
+        try:
+            header = struct.pack('>BB36sI', msg_type, name_len, uid_bytes, payload_size)
+        except Exception as e:
+            raise Exception(f"error al empaquetar el header: {e}")
+
+        packet = header + event_name_bytes + data_bytes
+
+        with self._write_mu:
+            conn = self.get_conn()
+            if not conn:
+                raise Exception("conexión no disponible")
+            try:
+                conn.sendall(packet)
+            except Exception as e:
+                raise Exception(f"error al escribir en socket: {e}")
+
+    def listen(self):
+        stop_event = threading.Event()
+
+        def handle_signal(signum, frame):
+            stop_event.set()
+
+        try:
+            signal.signal(signal.SIGINT, handle_signal)
+            signal.signal(signal.SIGTERM, handle_signal)
+        except ValueError:
+            pass
+
+        try:
+            while not stop_event.is_set():
+                stop_event.wait(0.5)
+        except KeyboardInterrupt:
+            pass
+            
+        print(f"\n[client {self.name}] Apagando el cliente de forma segura...")
+        self.close()

subnx-0.1.0/subnx/events.py

@@ -0,0 +1,37 @@
+# subnx/events.py
+import threading
+from typing import Callable, List, Tuple, Optional, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import Client
+    from .models import Event
+
+# EventHandler define la firma limpia para el desarrollador
+EventHandler = Callable[['Event', 'Client'], None]
+
+class EventRouter:
+    def __init__(self):
+        self._mu = threading.Lock()
+        self.handlers: Dict[str, EventHandler] = {}
+
+    def add_event(self, event_name: str, handler: EventHandler) -> None:
+        with self._mu:
+            self.handlers[event_name] = handler
+
+    def remove_event(self, event_name: str) -> None:
+        with self._mu:
+            if event_name in self.handlers:
+                del self.handlers[event_name]
+
+    def get_registered_event_names(self) -> List[str]:
+        with self._mu:
+            return list(self.handlers.keys())
+
+    def get_handler(self, event_name: str) -> Tuple[Optional[EventHandler], bool]:
+        with self._mu:
+            handler = self.handlers.get(event_name)
+            exists = handler is not None
+            return handler, exists
+
+# GlobalEvents es el enrutador principal del SDK
+GlobalEvents = EventRouter()

subnx-0.1.0/subnx/handlers.py

@@ -0,0 +1,74 @@
+# subnx/handlers.py
+import json
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from .events import GlobalEvents
+
+if TYPE_CHECKING:
+    from .client import Client
+    from .models import Event
+
+def handle_events(e: 'Event', conn: 'Client', client_name: str, latency: int):
+    if e.event == "connect":
+        handle_connect_event(e, conn, client_name, latency)
+        return
+
+    handler, exists = GlobalEvents.get_handler(e.event)
+    if not exists:
+        print(f"Evento no reconocido: {e.server_uid} {e.event}")
+        from .models import State
+        e.reply(conn, State(status=False, message="Evento no reconocido", error="NOT_FOUND"))
+        return
+
+    # 🐕 EL PERRO GUARDIÁN DE DOS FASES
+    def guard_dog():
+        if e.replied.wait(timeout=0.1): 
+            return
+            
+        e.extended.set() # Activar prórroga
+        
+        from .models import MessageState
+        keep_alive = MessageState(status=True, server_uid=e.server_uid, message="El worker está trabajando", error="", process_status=1)
+        keep_alive.send(conn) # 🌟 Método directo del objeto
+
+        if not e.replied.wait(timeout=28.0):
+            abort = MessageState(status=False, server_uid=e.server_uid, message="Worker colgado", error="WORKER_HANG", process_status=2)
+            abort.send(conn)
+
+    threading.Thread(target=guard_dog, daemon=True).start()
+
+    # 🚀 Ejecutamos al desarrollador
+    try:
+        handler(e, conn)
+    except Exception as ex:
+        print(f"Error en el handler del desarrollador: {ex}")
+
+def handle_connect_event(e: 'Event', conn: 'Client', client_name: str, latency: int):
+    from .stats import get_system_stats
+    from .models import ClientHardwareResourcesStatistics, ClientInformation, EventsSubscribed, State
+    
+    stats = ClientHardwareResourcesStatistics()
+    try:
+        get_system_stats(stats)
+    except Exception as err:
+        print(f"Error obteniendo estadísticas del sistema: {err}")
+        return
+
+    api_key_str = conn.api_key if conn.api_key else ""
+
+    info = ClientInformation(
+        client_name=client_name,
+        api_key=api_key_str,
+        latency=float(latency),
+        resources=stats,
+        events=EventsSubscribed(GlobalEvents.get_registered_event_names())
+    )
+
+    try:
+        json_data = json.dumps(info.to_dict())
+        e.reply(conn, State(status=True, message="Cliente conectado con exito.", data=json_data))
+        conn.set_ready()
+    except Exception as err:
+        e.reply(conn, State(status=False, message="Error interno de JSON", error=str(err)))

subnx-0.1.0/subnx/models.py

@@ -0,0 +1,202 @@
+# subnx/models.py
+import json
+import uuid
+import threading
+import queue
+import time
+from typing import Any, Callable, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import Client
+
+class ClientHardwareResourcesStatistics:
+    def __init__(self):
+        self.cpu_usage: float = 0.0
+        self.memory_usage: float = 0.0
+        self.disk_usage: float = 0.0
+        self.disk_busy: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "cpu_usage": self.cpu_usage,
+            "memory_usage": self.memory_usage,
+            "disk_usage": self.disk_usage,
+            "disk_busy": self.disk_busy
+        }
+
+class EventsSubscribed:
+    def __init__(self, events: List[str]):
+        self.events = events
+
+    def to_dict(self) -> dict:
+        return {"events": self.events}
+
+class ClientInformation:
+    def __init__(self, client_name: str, api_key: str, latency: float, 
+                 resources: ClientHardwareResourcesStatistics, events: EventsSubscribed):
+        self.client_name = client_name
+        self.api_key = api_key
+        self.latency = latency
+        self.resources = resources
+        self.events = events
+
+    def to_dict(self) -> dict:
+        return {
+            "client_name": self.client_name,
+            "api_key": self.api_key,
+            "latency": self.latency,
+            "resources": self.resources.to_dict(),
+            "events": self.events.to_dict()
+        }
+
+class State:
+    def __init__(self, status: bool, message: str, error: str = "", data: Any = None, uid: str = ""):
+        self.status = status
+        self.message = message
+        self.error = error
+        self.uid = uid
+        self.server_uid = ""
+        self.data = data
+        self._raw_data: str = "" # 🌟 MAGIA: Bytes crudos de Go
+
+    def to_dict(self) -> dict:
+        return {
+            "status": self.status,
+            "message": self.message,
+            "error": self.error,
+            "uid": self.uid,
+            "data": self.data
+        }
+
+    # 🌟 METODO BIND ENCAPSULADO
+    def bind(self, target: Any) -> None:
+        if not self._raw_data:
+            return
+        parsed = json.loads(self._raw_data)
+        if isinstance(parsed, dict):
+            if isinstance(target, dict):
+                target.update(parsed)
+            elif hasattr(target, '__dict__'):
+                for k, v in parsed.items():
+                    setattr(target, k, v)
+        elif isinstance(parsed, list) and isinstance(target, list):
+            target.clear()
+            target.extend(parsed)
+
+    def to_string(self) -> str:
+        return f"State{{Status: {self.status}, Message: '{self.message}', Error: '{self.error}', Data: {self.data}, UID: '{self.uid}'}}"
+
+class Event:
+    def __init__(self, event: str, data: Any, uid: str = ""):
+        self.event = event
+        self.data = data
+        self.uid = uid
+        self.server_uid = ""
+        self._raw_data: str = "" # 🌟 MAGIA: Bytes crudos de Go
+        
+        # Emulación de los canales y sync.Once
+        self.replied = threading.Event()
+        self.extended = threading.Event()
+        self._reply_once = threading.Lock()
+        self._has_replied = False
+
+    def to_dict(self) -> dict:
+        return {
+            "event": self.event,
+            "data": self.data,
+            "uid": self.uid
+        }
+
+    # 🌟 METODO BIND ENCAPSULADO
+    def bind(self, target: Any) -> None:
+        if not self._raw_data:
+            return
+        parsed = json.loads(self._raw_data)
+        if isinstance(parsed, dict):
+            if isinstance(target, dict):
+                target.update(parsed)
+            elif hasattr(target, '__dict__'):
+                for k, v in parsed.items():
+                    setattr(target, k, v)
+        elif isinstance(parsed, list) and isinstance(target, list):
+            target.clear()
+            target.extend(parsed)
+
+    # 🌟 ENCAPSULACIÓN: SendData le pertenece a Event
+    def send_data(self, client: 'Client', timeout_sec: Optional[float] = 65.0, callback: Optional[Callable[[State], None]] = None) -> None:
+        self.uid = str(uuid.uuid4())
+
+        # 1. Enviamos el Tipo 1 y le pasamos e.event
+        client.write_packet(1, self.event, "", self.to_dict())
+
+        # req := &pendingRequest{ Data: make(chan State, 1) }
+        req_queue = queue.Queue(maxsize=1) 
+        
+        with client.pending_requests_mu:
+            client.pending_requests[self.uid] = req_queue
+
+        if timeout_sec is None:
+            timeout_sec = 65.0
+
+        if callback is not None:
+            def wait_sync():
+                try:
+                    state = req_queue.get(timeout=timeout_sec)
+                    if state.status:
+                        callback(state)
+                    else:
+                        print(f"error del servidor: {state.error}")
+                except queue.Empty:
+                    with client.pending_requests_mu:
+                        client.pending_requests.pop(self.uid, None)
+                    print(f"timeout esperando respuesta para UID {self.uid}")
+            threading.Thread(target=wait_sync, daemon=True).start()
+        else:
+            def wait_async():
+                try:
+                    state = req_queue.get(timeout=timeout_sec)
+                    if not state.status:
+                        print(f"Respuesta asíncrona fallida: {state.error}")
+                except queue.Empty:
+                    with client.pending_requests_mu:
+                        client.pending_requests.pop(self.uid, None)
+            threading.Thread(target=wait_async, daemon=True).start()
+
+    # 🌟 ENCAPSULACIÓN: Reply le pertenece a Event
+    def reply(self, client: 'Client', state: State):
+        # e.replyOnce.Do(...)
+        with self._reply_once:
+            if not self._has_replied:
+                self.replied.set() # close(e.replied)
+                self._has_replied = True
+
+        state.uid = self.uid
+        client.write_packet(2, "", self.server_uid, state.to_dict())
+
+
+class MessageState:
+    def __init__(self, status: bool, server_uid: str, message: str, error: str, process_status: int):
+        self.status = status
+        self.server_uid = server_uid
+        self.message = message
+        self.error = error
+        self.process_status = process_status
+
+    def to_dict(self) -> dict:
+        return {
+            "status": self.status,
+            "server_uid": self.server_uid,
+            "state": self.message,
+            "error": self.error,
+            "process_status": self.process_status
+        }
+        
+    # 🌟 ENCAPSULACIÓN: send le pertenece a MessageState
+    def send(self, client: 'Client'):
+        client.write_packet(3, "", self.server_uid, self.to_dict())
+
+    def to_string(self) -> str:
+        return f"MessageState{{Status: {self.status}, ServerUID: '{self.server_uid}', Message: '{self.message}', Error: '{self.error}'}}"
+
+# Tipo equivalente a: type ResponseCallback func(response State)
+ResponseCallback = Callable[[State], None]

subnx-0.1.0/subnx/protocol.py

@@ -0,0 +1,95 @@
+# subnx/protocol.py
+import struct
+import json
+import queue
+import socket
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import Client
+
+def _recv_exactly(conn: socket.socket, n: int) -> bytes:
+    data = bytearray()
+    while len(data) < n:
+        packet = conn.recv(n - len(data))
+        if not packet:
+            raise Exception("EOF")
+        data.extend(packet)
+    return bytes(data)
+
+def read_loop(client: 'Client', server_status: queue.Queue, latency: float):
+    from .models import Event, State, MessageState
+    from .handlers import handle_events
+
+    while not client._closed:
+        try:
+            conn = client.get_conn()
+            if not conn:
+                raise Exception("EOF")
+
+            # 1. LEER PREFIJO FIJO (42 Bytes)
+            header = _recv_exactly(conn, 42)
+            msg_type, name_len, uid_bytes, payload_size = struct.unpack('>BB36sI', header)
+            
+            message_uid = uid_bytes.decode('utf-8').rstrip('\x00')
+
+            # 2. LEER CUERPO DINÁMICO
+            body = _recv_exactly(conn, name_len + payload_size)
+            
+            # 3. SEPARAMOS LOS DATOS
+            event_name = body[:name_len].decode('utf-8')
+            data_bytes = body[name_len:]
+
+            try:
+                obj = json.loads(data_bytes.decode('utf-8'))
+            except:
+                continue
+
+            if msg_type == 1:
+                event_val = event_name if event_name else obj.get('event', '')
+                
+                # 🌟 TRASLADO MÁGICO
+                e = Event(event=event_val, data=obj.get('data'), uid=obj.get('uid', ''))
+                e.server_uid = message_uid
+                
+                # Interceptamos el bloque data crudo (equivalente a json.RawMessage)
+                if 'data' in obj:
+                    e._raw_data = json.dumps(obj['data'])
+                
+                ack = MessageState(status=True, server_uid=message_uid, message="ACK recibido Evento", error="", process_status=1)
+                ack.send(client)
+
+                import threading
+                threading.Thread(target=handle_events, args=(e, client, client.name, int(latency)), daemon=True).start()
+
+            elif msg_type == 2:
+                # 🌟 TRASLADO MÁGICO PARA STATE
+                state = State(
+                    status=obj.get('status', False),
+                    message=obj.get('message', ''),
+                    error=obj.get('error', ''),
+                    data=obj.get('data'),
+                    uid=obj.get('uid', '')
+                )
+                state.server_uid = message_uid
+                
+                if 'data' in obj:
+                    state._raw_data = json.dumps(obj['data'])
+
+                ack = MessageState(status=True, server_uid=message_uid, message="ACK recibido State", error="", process_status=2)
+                ack.send(client)
+
+                state_uid = state.uid
+                with client.pending_requests_mu:
+                    if state_uid in client.pending_requests:
+                        req_queue = client.pending_requests.pop(state_uid)
+                        req_queue.put(state) # Desbloquea a chan State
+                    else:
+                        print(f"Proceso no encontrado para State UID: {state_uid}")
+
+            elif msg_type == 3:
+                pass # ACKs ignorados
+
+        except Exception as e:
+            server_status.put(False)
+            return

subnx-0.1.0/subnx/stats.py

@@ -0,0 +1,26 @@
+# subnx/stats.py
+import time
+import psutil
+from .models import ClientHardwareResourcesStatistics
+
+def get_system_stats(c: ClientHardwareResourcesStatistics) -> None:
+    try:
+        c.cpu_usage = psutil.cpu_percent(interval=0.0)
+        c.memory_usage = psutil.virtual_memory().percent
+        c.disk_usage = psutil.disk_usage('/').percent
+
+        io_start = psutil.disk_io_counters()
+        time.sleep(1.0) 
+        io_end = psutil.disk_io_counters()
+
+        if io_start and io_end:
+            total_io = (io_end.read_bytes - io_start.read_bytes) + (io_end.write_bytes - io_start.write_bytes)
+            if total_io > 0:
+                max_throughput = float(100 * 1024 * 1024) 
+                disk_busy = (float(total_io) / max_throughput) * 100.0
+                if disk_busy > 100.0:
+                    disk_busy = 100.0
+                c.disk_busy = disk_busy
+
+    except Exception as e:
+        raise Exception(f"error obteniendo métricas: {e}")

subnx-0.1.0/subnx.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: subnx
+Version: 0.1.0
+Summary: High-concurrency event-driven network framework and SDK
+Author-email: Humberto Manuel Cabrera <humbertomanuel_cabrera@outlook.es>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9.0

subnx-0.1.0/subnx.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+subnx/__init__.py
+subnx/client.py
+subnx/events.py
+subnx/handlers.py
+subnx/models.py
+subnx/protocol.py
+subnx/stats.py
+subnx.egg-info/PKG-INFO
+subnx.egg-info/SOURCES.txt
+subnx.egg-info/dependency_links.txt
+subnx.egg-info/requires.txt
+subnx.egg-info/top_level.txt

subnx-0.1.0/subnx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

subnx-0.1.0/subnx.egg-info/requires.txt

@@ -0,0 +1 @@
+psutil>=5.9.0

subnx-0.1.0/subnx.egg-info/top_level.txt

@@ -0,0 +1 @@
+subnx