netrun-sim 0.1.1__tar.gz → 0.1.2__tar.gz

{netrun_sim-0.1.1 → netrun_sim-0.1.2}/Cargo.lock

@@ -123,9 +123,10 @@ dependencies = [
 
 [[package]]
 name = "netrun-sim"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "indexmap",
+ "pyo3",
  "thiserror",
  "ulid",
  "utcnow",

{netrun_sim-0.1.1 → netrun_sim-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netrun-sim
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: python-ulid>=1.0

{netrun_sim-0.1.1 → netrun_sim-0.1.2}/core/Cargo.toml

@@ -1,13 +1,18 @@
 [package]
 name = "netrun-sim"
 description = "A flow-based development (FBD) simulation engine."
-version = "0.1.0"
+version = "0.1.2"
 edition = "2024"
 license-file = "../../LICENSE"
 repository = "https://github.com/lukastk/netrun/"
 
+[features]
+default = []
+python = ["pyo3"]
+
 [dependencies]
 indexmap = "2.12.1"
 thiserror = "2.0"
 ulid = "=1.1.0"
 utcnow = "0.2.7"
+pyo3 = { version = "0.23", features = ["abi3-py38"], optional = true }

{netrun_sim-0.1.1 → netrun_sim-0.1.2}/core/examples/diamond_flow.rs

@@ -13,11 +13,11 @@
 //! - Synchronization: D's epoch only triggers when both inputs are present
 
 use netrun_sim::graph::{
-    Edge, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
+    Edge, Graph, MaxSalvos, Node, PacketCount, Port, PortRef, PortSlotSpec, PortState, PortType,
     SalvoCondition, SalvoConditionTerm,
 };
 use netrun_sim::net::{
-    Net, NetAction, NetActionResponse, NetActionResponseData, PacketLocation,
+    NetAction, NetActionResponse, NetActionResponseData, NetSim, PacketLocation,
 };
 use std::collections::HashMap;
 
@@ -27,7 +27,7 @@ fn main() {
     println!("Created diamond graph: A -> B,C -> D");
     println!("D requires inputs from BOTH B and C\n");
 
-    let mut net = Net::new(graph);
+    let mut net = NetSim::new(graph);
 
     // Create two packets and place them on edges from A
     let packet1 = create_packet(&mut net);
@@ -36,19 +36,28 @@ fn main() {
 
     // Place packet1 on edge A -> B
     let edge_a_b = edge_location("A", "out1", "B", "in");
-    net.do_action(&NetAction::TransportPacketToLocation(packet1.clone(), edge_a_b));
+    net.do_action(&NetAction::TransportPacketToLocation(
+        packet1.clone(),
+        edge_a_b,
+    ));
     println!("Placed packet1 on edge A -> B");
 
     // Place packet2 on edge A -> C
     let edge_a_c = edge_location("A", "out2", "C", "in");
-    net.do_action(&NetAction::TransportPacketToLocation(packet2.clone(), edge_a_c));
+    net.do_action(&NetAction::TransportPacketToLocation(
+        packet2.clone(),
+        edge_a_c,
+    ));
     println!("Placed packet2 on edge A -> C");
 
     // Run network - packets move to B and C, triggering epochs
-    net.do_action(&NetAction::RunNetUntilBlocked);
+    net.run_until_blocked();
 
     let startable = net.get_startable_epochs();
-    println!("\nAfter first run: {} startable epochs (B and C)", startable.len());
+    println!(
+        "\nAfter first run: {} startable epochs (B and C)",
+        startable.len()
+    );
 
     // Process B and C, sending outputs to D
     for epoch_id in startable {
@@ -70,8 +79,14 @@ fn main() {
         let output = create_packet_in_epoch(&mut net, &started.id);
 
         // Load into output port and send
-        net.do_action(&NetAction::LoadPacketIntoOutputPort(output, "out".to_string()));
-        net.do_action(&NetAction::SendOutputSalvo(started.id.clone(), "default".to_string()));
+        net.do_action(&NetAction::LoadPacketIntoOutputPort(
+            output,
+            "out".to_string(),
+        ));
+        net.do_action(&NetAction::SendOutputSalvo(
+            started.id.clone(),
+            "default".to_string(),
+        ));
 
         // Finish epoch
         net.do_action(&NetAction::FinishEpoch(started.id));
@@ -79,7 +94,7 @@ fn main() {
     }
 
     // Run network - packets move from B->D and C->D edges to D's input ports
-    net.do_action(&NetAction::RunNetUntilBlocked);
+    net.run_until_blocked();
 
     // Check D's input ports
     let d_in1 = PacketLocation::InputPort("D".to_string(), "in1".to_string());
@@ -94,7 +109,10 @@ fn main() {
 
     if let Some(d_epoch_id) = startable_d.first() {
         let d_epoch = net.get_epoch(d_epoch_id).unwrap();
-        println!("D's epoch received {} packets from both branches!", d_epoch.in_salvo.packets.len());
+        println!(
+            "D's epoch received {} packets from both branches!",
+            d_epoch.in_salvo.packets.len()
+        );
     }
 
     println!("\nDiamond flow example complete!");
@@ -106,9 +124,20 @@ fn create_diamond_graph() -> Graph {
         name: "A".to_string(),
         in_ports: HashMap::new(),
         out_ports: [
-            ("out1".to_string(), Port { slots_spec: PortSlotSpec::Infinite }),
-            ("out2".to_string(), Port { slots_spec: PortSlotSpec::Infinite }),
-        ].into(),
+            (
+                "out1".to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            ),
+            (
+                "out2".to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            ),
+        ]
+        .into(),
         in_salvo_conditions: HashMap::new(),
         out_salvo_conditions: HashMap::new(),
     };
@@ -123,15 +152,31 @@ fn create_diamond_graph() -> Graph {
     let node_d = Node {
         name: "D".to_string(),
         in_ports: [
-            ("in1".to_string(), Port { slots_spec: PortSlotSpec::Infinite }),
-            ("in2".to_string(), Port { slots_spec: PortSlotSpec::Infinite }),
-        ].into(),
+            (
+                "in1".to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            ),
+            (
+                "in2".to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            ),
+        ]
+        .into(),
         out_ports: HashMap::new(),
         in_salvo_conditions: [(
             "default".to_string(),
             SalvoCondition {
-                max_salvos: 1,
-                ports: vec!["in1".to_string(), "in2".to_string()],
+                max_salvos: MaxSalvos::Finite(1),
+                ports: [
+                    ("in1".to_string(), PacketCount::All),
+                    ("in2".to_string(), PacketCount::All),
+                ]
+                .into_iter()
+                .collect(),
                 // Require BOTH inputs to be non-empty
                 term: SalvoConditionTerm::And(vec![
                     SalvoConditionTerm::Port {
@@ -144,7 +189,8 @@ fn create_diamond_graph() -> Graph {
                     },
                 ]),
             },
-        )].into(),
+        )]
+        .into(),
         out_salvo_conditions: HashMap::new(),
     };
 
@@ -163,30 +209,46 @@ fn create_diamond_graph() -> Graph {
 fn create_simple_node(name: &str) -> Node {
     Node {
         name: name.to_string(),
-        in_ports: [("in".to_string(), Port { slots_spec: PortSlotSpec::Infinite })].into(),
-        out_ports: [("out".to_string(), Port { slots_spec: PortSlotSpec::Infinite })].into(),
+        in_ports: [(
+            "in".to_string(),
+            Port {
+                slots_spec: PortSlotSpec::Infinite,
+            },
+        )]
+        .into(),
+        out_ports: [(
+            "out".to_string(),
+            Port {
+                slots_spec: PortSlotSpec::Infinite,
+            },
+        )]
+        .into(),
         in_salvo_conditions: [(
             "default".to_string(),
             SalvoCondition {
-                max_salvos: 1,
-                ports: vec!["in".to_string()],
+                max_salvos: MaxSalvos::Finite(1),
+                ports: [("in".to_string(), PacketCount::All)].into_iter().collect(),
                 term: SalvoConditionTerm::Port {
                     port_name: "in".to_string(),
                     state: PortState::NonEmpty,
                 },
             },
-        )].into(),
+        )]
+        .into(),
         out_salvo_conditions: [(
             "default".to_string(),
             SalvoCondition {
-                max_salvos: 0,
-                ports: vec!["out".to_string()],
+                max_salvos: MaxSalvos::Infinite,
+                ports: [("out".to_string(), PacketCount::All)]
+                    .into_iter()
+                    .collect(),
                 term: SalvoConditionTerm::Port {
                     port_name: "out".to_string(),
                     state: PortState::NonEmpty,
                 },
             },
-        )].into(),
+        )]
+        .into(),
     }
 }
 
@@ -220,14 +282,14 @@ fn edge_location(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str)
     })
 }
 
-fn create_packet(net: &mut Net) -> ulid::Ulid {
+fn create_packet(net: &mut NetSim) -> ulid::Ulid {
     match net.do_action(&NetAction::CreatePacket(None)) {
         NetActionResponse::Success(NetActionResponseData::Packet(id), _) => id,
         _ => panic!("Failed to create packet"),
     }
 }
 
-fn create_packet_in_epoch(net: &mut Net, epoch_id: &ulid::Ulid) -> ulid::Ulid {
+fn create_packet_in_epoch(net: &mut NetSim, epoch_id: &ulid::Ulid) -> ulid::Ulid {
     match net.do_action(&NetAction::CreatePacket(Some(epoch_id.clone()))) {
         NetActionResponse::Success(NetActionResponseData::Packet(id), _) => id,
         _ => panic!("Failed to create packet in epoch"),

{netrun_sim-0.1.1 → netrun_sim-0.1.2}/core/examples/linear_flow.rs

@@ -8,11 +8,11 @@
 //! - Sending output salvos to continue flow
 
 use netrun_sim::graph::{
-    Edge, Graph, Node, Port, PortRef, PortSlotSpec, PortState, PortType,
+    Edge, Graph, MaxSalvos, Node, PacketCount, Port, PortRef, PortSlotSpec, PortState, PortType,
     SalvoCondition, SalvoConditionTerm,
 };
 use netrun_sim::net::{
-    Net, NetAction, NetActionResponse, NetActionResponseData, PacketLocation,
+    NetAction, NetActionResponse, NetActionResponseData, NetSim, PacketLocation,
 };
 use std::collections::HashMap;
 
@@ -22,7 +22,7 @@ fn main() {
     println!("Created graph with {} nodes", graph.nodes().len());
 
     // Create a network from the graph
-    let mut net = Net::new(graph);
+    let mut net = NetSim::new(graph);
 
     // Create a packet outside the network
     let packet_id = match net.do_action(&NetAction::CreatePacket(None)) {
@@ -46,11 +46,14 @@ fn main() {
             port_name: "in".to_string(),
         },
     });
-    net.do_action(&NetAction::TransportPacketToLocation(packet_id.clone(), edge_a_b));
+    net.do_action(&NetAction::TransportPacketToLocation(
+        packet_id.clone(),
+        edge_a_b,
+    ));
     println!("Placed packet on edge A -> B");
 
     // Run the network - packet moves to B's input port and triggers an epoch
-    net.do_action(&NetAction::RunNetUntilBlocked);
+    net.run_until_blocked();
     println!("Ran network until blocked");
 
     // Check for startable epochs
@@ -71,18 +74,25 @@ fn main() {
                 println!("Consumed input packet");
 
                 // Create an output packet
-                let output_packet = match net.do_action(&NetAction::CreatePacket(Some(epoch.id.clone()))) {
-                    NetActionResponse::Success(NetActionResponseData::Packet(id), _) => id,
-                    _ => panic!("Failed to create output packet"),
-                };
+                let output_packet =
+                    match net.do_action(&NetAction::CreatePacket(Some(epoch.id.clone()))) {
+                        NetActionResponse::Success(NetActionResponseData::Packet(id), _) => id,
+                        _ => panic!("Failed to create output packet"),
+                    };
                 println!("Created output packet: {}", output_packet);
 
                 // Load it into the output port
-                net.do_action(&NetAction::LoadPacketIntoOutputPort(output_packet.clone(), "out".to_string()));
+                net.do_action(&NetAction::LoadPacketIntoOutputPort(
+                    output_packet.clone(),
+                    "out".to_string(),
+                ));
                 println!("Loaded packet into output port");
 
                 // Send the output salvo
-                net.do_action(&NetAction::SendOutputSalvo(epoch.id.clone(), "default".to_string()));
+                net.do_action(&NetAction::SendOutputSalvo(
+                    epoch.id.clone(),
+                    "default".to_string(),
+                ));
                 println!("Sent output salvo - packet is now on edge B -> C");
 
                 // Finish the epoch
@@ -90,12 +100,15 @@ fn main() {
                 println!("Finished epoch");
 
                 // Run the network again - packet moves to C
-                net.do_action(&NetAction::RunNetUntilBlocked);
+                net.run_until_blocked();
                 println!("Ran network until blocked again");
 
                 // Check for new startable epochs at C
                 let startable_c = net.get_startable_epochs();
-                println!("New startable epochs (should be at C): {}", startable_c.len());
+                println!(
+                    "New startable epochs (should be at C): {}",
+                    startable_c.len()
+                );
             }
             _ => panic!("Failed to start epoch"),
         }
@@ -125,12 +138,26 @@ fn create_linear_graph() -> Graph {
 fn create_node(name: &str, in_ports: Vec<&str>, out_ports: Vec<&str>) -> Node {
     let in_ports_map: HashMap<String, Port> = in_ports
         .iter()
-        .map(|p| (p.to_string(), Port { slots_spec: PortSlotSpec::Infinite }))
+        .map(|p| {
+            (
+                p.to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            )
+        })
         .collect();
 
     let out_ports_map: HashMap<String, Port> = out_ports
         .iter()
-        .map(|p| (p.to_string(), Port { slots_spec: PortSlotSpec::Infinite }))
+        .map(|p| {
+            (
+                p.to_string(),
+                Port {
+                    slots_spec: PortSlotSpec::Infinite,
+                },
+            )
+        })
         .collect();
 
     // Default input salvo condition: trigger when any input port is non-empty
@@ -139,8 +166,11 @@ fn create_node(name: &str, in_ports: Vec<&str>, out_ports: Vec<&str>) -> Node {
         in_salvo_conditions.insert(
             "default".to_string(),
             SalvoCondition {
-                max_salvos: 1,
-                ports: in_ports.iter().map(|s| s.to_string()).collect(),
+                max_salvos: MaxSalvos::Finite(1),
+                ports: in_ports
+                    .iter()
+                    .map(|s| (s.to_string(), PacketCount::All))
+                    .collect(),
                 term: SalvoConditionTerm::Port {
                     port_name: in_ports[0].to_string(),
                     state: PortState::NonEmpty,
@@ -155,8 +185,11 @@ fn create_node(name: &str, in_ports: Vec<&str>, out_ports: Vec<&str>) -> Node {
         out_salvo_conditions.insert(
             "default".to_string(),
             SalvoCondition {
-                max_salvos: 0, // unlimited
-                ports: out_ports.iter().map(|s| s.to_string()).collect(),
+                max_salvos: MaxSalvos::Infinite,
+                ports: out_ports
+                    .iter()
+                    .map(|s| (s.to_string(), PacketCount::All))
+                    .collect(),
                 term: SalvoConditionTerm::Port {
                     port_name: out_ports[0].to_string(),
                     state: PortState::NonEmpty,