risansym 0.1.0__py3-none-any.whl

risansym/__init__.py

@@ -0,0 +1 @@
+

risansym/event.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(order=True, slots=True)
+class Event:
+    """Encapsula la información que se intercambia entre procesos activos."""
+
+    time: float
+    # field(compare=False) evita desempates por nombre/IDs si los tiempos son iguales
+    name: str = field(compare=False)
+    target: int = field(compare=False)
+    source: int = field(compare=False)
+    payload: dict = field(default_factory=dict, compare=False)
+  

risansym/model.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from risansym.event import Event
+
+if TYPE_CHECKING:
+    from risansym.process import Process
+
+
+class Model(ABC):
+    """Interfaz abstracta (contrato) para los algoritmos distribuidos."""
+
+    def __init__(self) -> None:
+        self.clock: float = 0.0
+        self.process: Process | None = None
+        self.neighbors: list[int] = []
+        self.id: int = 0
+
+    def set_time(self, time: float) -> None:
+        self.clock = time
+
+    def set_process(self, process: Process, neighbors: list[int], node_id: int) -> None:
+        self.process = process
+        self.neighbors = neighbors
+        self.id = node_id
+
+    def transmit(self, event: Event) -> None:
+        if self.process:
+            self.process.transmit(event)
+
+    def log(self, message: str) -> None:
+        """Convención: Usar este método en lugar de print() para reportar eventos lógicos de la capa de aplicación."""
+        if self.process:
+            self.process.log(message)
+
+    @abstractmethod
+    def init(self) -> None:
+        """Inicialización del estado local (implementado por la subclase)."""
+
+    @abstractmethod
+    def receive(self, event: Event) -> None:
+        """Lógica de transición de la máquina de estados (implementado por subclase)."""

risansym/process.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from risansym.event import Event
+from risansym.model import Model
+from risansym.simulator import Simulator
+
+
+class Process:
+    """Entidad que reside en un vértice de la topología."""
+
+    def __init__(self, neighbors: list[int], engine: Simulator, node_id: int) -> None:
+        self.neighbors = neighbors
+        self.engine = engine
+        self.id = node_id
+        self.model: Model | None = None
+
+    def set_model(self, model: Model) -> None:
+        self.model = model
+        self.model.set_process(self, self.neighbors, self.id)
+        self.model.init()
+
+    def set_time(self, time: float) -> None:
+        if self.model:
+            self.model.set_time(time)
+
+    def transmit(self, event: Event) -> None:
+        self.engine.insert_event(event)
+
+    def receive(self, event: Event) -> None:
+        if self.model:
+            self.model.receive(event)
+
+    def log(self, message: str) -> None:
+        self.engine.log_app_event(self.id, message)

risansym/schemas.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel, Field
+from typing import Any, Literal, Union
+
+class TransmitEvent(BaseModel):
+    action: Literal["TRANSMIT"] = "TRANSMIT"
+    clock: float = Field(..., description="Tiempo en el que el emisor disparó el evento")
+    event_time: float = Field(..., description="Tiempo calculado de llegada al destino")
+    source: int
+    target: int
+    name: str
+    payload: Any
+
+class ReceiveEvent(BaseModel):
+    action: Literal["RECEIVE"] = "RECEIVE"
+    clock: float = Field(..., description="Tiempo en el que el nodo procesa el evento")
+    source: int
+    target: int
+    name: str
+    payload: Any
+
+class AppLogEvent(BaseModel):
+    action: Literal["APP_LOG"] = "APP_LOG"
+    clock: float
+    source: int
+    message: str
+
+# Agrupación de todos los eventos válidos
+TraceEvent = Union[TransmitEvent, ReceiveEvent, AppLogEvent]
+
+class TraceMetadata(BaseModel):
+    schema_version: Literal["1.0"] = "1.0"
+    algorithm: str
+    topology: str
+    tag: str | None = None
+    execution_date: str
+    parameters: dict[str, Any]
+    metrics: dict[str, Any]
+
+class TraceOutput(BaseModel):
+    metadata: TraceMetadata
+    trace: list[TraceEvent]

risansym/simulation.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import datetime
+import time
+from pathlib import Path
+
+from risansym.event import Event
+from risansym.model import Model
+from risansym.process import Process
+from risansym.simulator import Simulator
+from risansym.schemas import TraceMetadata
+
+
+class Simulation:
+    """Orquestador global del grafo computacional y ciclo de simulación."""
+
+    def __init__(self, filename: str | Path, maxtime: float, algo_name: str = "UnknownAlgo", debug: bool = True, trace: bool | str | Path = False, trace_dir: str = "traces", trace_tag: str | None = None) -> None:
+        from risansym.trace import TraceCollector
+        
+        self.filename = Path(filename)
+        self.algo_name = algo_name
+        self.trace = trace
+        self.trace_dir = trace_dir
+        self.trace_tag = trace_tag
+        
+        self.collector = TraceCollector() if trace else None
+        self.engine = Simulator(maxtime, debug=debug, collector=self.collector)
+        self.graph = self._load_adjacency_matrix(self.filename)
+        # Índice 0 reservado como None; nodos indexados desde 1
+        self.table: list[Process | None] = [None] + [
+            Process(row, self.engine, i)
+            for i, row in enumerate(self.graph, start=1)
+        ]
+
+    def _load_adjacency_matrix(self, filename: str | Path) -> list[list[int]]:
+        """Construye la topología G=(V,E) desde archivo."""
+        return [
+            [int(node) for node in line.split()]
+            for line in Path(filename).read_text().splitlines()
+            if line.strip()
+        ]
+
+    def set_model(self, model: Model, node_id: int) -> None:
+        if process := self.table[node_id]:  # walrus operator: asigna y evalúa en una línea
+            process.set_model(model)
+
+    def init(self, event: Event) -> None:
+        self.engine.insert_event(event)
+
+    def _execute(self) -> None:
+        """Bucle principal: extrae y enruta eventos hasta agotar la agenda."""
+        start_real_time = time.perf_counter()
+        
+        while self.engine.is_on:
+            event = self.engine.pop_event()
+            if process := self.table[event.target]:  # walrus operator
+                process.set_time(event.time)
+                process.receive(event)
+                
+        end_real_time = time.perf_counter()
+        
+        self.execution_metrics = {
+            "simulated_time_elapsed": self.engine.clock,
+            "total_messages": self.collector.get_event_count() if self.collector else 0,
+            "execution_real_time_sec": round(end_real_time - start_real_time, 5)
+        }
+        
+    def _save_trace(self) -> None:
+        """Serializa y persiste la traza de eventos simulados con sus metadatos."""
+        grafo_name = self.filename.stem
+        tag = f"_{self.trace_tag}" if self.trace_tag else ""
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        if isinstance(self.trace, (str, Path)) and not isinstance(self.trace, bool):
+            trace_path = Path(self.trace)
+        else:
+            file_name = f"{self.algo_name}_{grafo_name}{tag}_{timestamp}.json"
+            trace_path = Path(self.trace_dir) / self.algo_name / file_name
+            
+        total_edges = sum(len(neighbors) for neighbors in self.graph)
+        total_nodes = len(self.table) - 1
+        
+        metadata = TraceMetadata(
+            schema_version="1.0",
+            algorithm=self.algo_name,
+            topology=grafo_name,
+            tag=self.trace_tag,
+            execution_date=timestamp,
+            parameters={
+                "max_time": self.engine.maxtime,
+                "total_nodes": total_nodes,
+                "total_edges": total_edges
+            },
+            metrics=self.execution_metrics
+        )
+        
+        if self.collector:
+            self.collector.dump(trace_path, metadata)
+
+    def run(self) -> None:
+        """Punto de entrada principal para ejecutar la simulación y guardar resultados."""
+        self._execute()
+        if self.trace:
+            self._save_trace()

risansym/simulator.py

@@ -0,0 +1,73 @@
+import heapq
+from typing import TYPE_CHECKING
+
+from risansym.event import Event
+from risansym.schemas import TransmitEvent, ReceiveEvent, AppLogEvent
+
+if TYPE_CHECKING:
+    from risansym.trace import TraceCollector
+
+
+class Simulator:
+    """Motor de simulación dirigido por eventos, coordinado por heap de mínimos."""
+
+    def __init__(self, maxtime: float, debug: bool = True, collector: 'TraceCollector | None' = None) -> None:
+        self.clock: float = 0.0
+        self.maxtime: float = maxtime
+        self._agenda: list[Event] = []
+        self.debug: bool = debug
+        self._collector = collector
+
+    def insert_event(self, event: Event) -> None:
+        """Inserta un evento en el heap si está dentro del horizonte temporal."""
+        if event.time <= self.maxtime:
+            heapq.heappush(self._agenda, event)
+            if self.debug:
+                print(f"[t={self.clock:.1f}] Nodo {event.source} TRANSMITE '{event.name}' -> Nodo {event.target} (llegará en t={event.time:.1f})")
+            
+            if self._collector:
+                self._collector.record(TransmitEvent(
+                    action="TRANSMIT",
+                    clock=self.clock,
+                    event_time=event.time,
+                    source=event.source,
+                    target=event.target,
+                    name=event.name,
+                    payload=event.payload
+                ))
+
+    def pop_event(self) -> Event:
+        """Extrae el evento más próximo y avanza el reloj global."""
+        event = heapq.heappop(self._agenda)
+        self.clock = event.time
+        if self.debug:
+            print(f"[t={self.clock:.1f}] Nodo {event.target} RECIBE '{event.name}' <- Nodo {event.source}")
+            
+        if self._collector:
+            self._collector.record(ReceiveEvent(
+                action="RECEIVE",
+                clock=self.clock,
+                source=event.source,
+                target=event.target,
+                name=event.name,
+                payload=event.payload
+            ))
+        return event
+
+    def log_app_event(self, source: int, message: str) -> None:
+        """Registra un evento lógico de aplicación en la traza."""
+        if self.debug:
+            print(f"[t={self.clock:.1f}] APP Nodo {source}: {message}")
+            
+        if self._collector:
+            self._collector.record(AppLogEvent(
+                action="APP_LOG",
+                clock=self.clock,
+                source=source,
+                message=message
+            ))
+
+    @property
+    def is_on(self) -> bool:
+        """True mientras existan eventos pendientes en la agenda."""
+        return bool(self._agenda)

risansym/trace.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+from risansym.schemas import TraceEvent, TraceMetadata, TraceOutput
+
+class TraceCollector:
+    """Responsable de acumular y persistir la traza de eventos simulados usando Pydantic."""
+    
+    def __init__(self) -> None:
+        self._trace: list[TraceEvent] = []
+
+    def record(self, entry: TraceEvent) -> None:
+        """Añade un evento estructurado a la traza en memoria."""
+        self._trace.append(entry)
+        
+    def get_event_count(self) -> int:
+        """Retorna el número de eventos registrados."""
+        return len(self._trace)
+
+    def dump(self, filepath: Path, metadata: TraceMetadata) -> None:
+        """Persiste la traza validada matemáticamente en un archivo JSON."""
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Validar y armar el objeto final
+        output = TraceOutput(metadata=metadata, trace=self._trace)
+        
+        # Guardar en disco
+        with filepath.open('w', encoding='utf-8') as f:
+            f.write(output.model_dump_json(indent=2))

risansym-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: risansym
+Version: 0.1.0
+Summary: A Discrete Event Simulator for Distributed Systems
+Project-URL: Homepage, https://github.com/PeraltaHD4K/risansym
+Project-URL: Repository, https://github.com/PeraltaHD4K/risansym.git
+Author-email: Diego Peralta Huerta <PeraltaHD4K@users.noreply.github.com>
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# Risansym
+
+A discrete event simulator for distributed systems algorithms.
+
+## Instalación
+
+```bash
+pip install risansym
+```

risansym-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+risansym/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+risansym/event.py,sha256=0ej1JgDxYlEjOqG49Hj-_Y1kAp-_TRMybDMhwxnfNUk,454
+risansym/model.py,sha256=15JgcToLsyaJyMq2pSl9BY3kKK8u1n65pKTaXTt7L6c,1347
+risansym/process.py,sha256=3hHn913RcMu3K2YdqsxZtom_7FFySvTA-Jd8QbhgE48,998
+risansym/schemas.py,sha256=3QiMTPgSrDgpJN04VnwIS2n6rh0hhkvlxnJVZfh84V0,1164
+risansym/simulation.py,sha256=XSAukcFil9cEEMJDSsiaKaq65-Q8EQ3nxopPVvm1w0E,4048
+risansym/simulator.py,sha256=I3-0HQYgeaZa5xOjAi16KSMhSOkkGIW_lLJguM0JCRc,2668
+risansym/trace.py,sha256=q_nmgvXG6bJJ1DPEHuYxYp0DffABU2hMofHjdO6TuKg,1059
+risansym-0.1.0.dist-info/METADATA,sha256=ZqMyd6ivgYv_CNRzBdaveugtelX5Knc6oD27rEBlpQs,540
+risansym-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+risansym-0.1.0.dist-info/RECORD,,

risansym-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any