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

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

@@ -90,12 +90,6 @@ dependencies = [
  "rustversion",
 ]
 
-[[package]]
-name = "itoa"
-version = "1.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ee5b5339afb4c41626dde77b7a611bd4f2c202b897852b4bcf5d03eddc61010"
-
 [[package]]
 name = "js-sys"
 version = "0.3.83"
@@ -118,12 +112,6 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
-[[package]]
-name = "memchr"
-version = "2.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
-
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -135,11 +123,10 @@ dependencies = [
 
 [[package]]
 name = "netrun-sim"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "indexmap",
- "serde",
- "serde_json",
+ "pyo3",
  "thiserror",
  "ulid",
  "utcnow",
@@ -151,7 +138,6 @@ version = "0.1.0"
 dependencies = [
  "netrun-sim",
  "pyo3",
- "serde_json",
  "ulid",
 ]
 
@@ -306,49 +292,6 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
- "serde_derive",
-]
-
-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.147"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6af14725505314343e673e9ecb7cd7e8a36aa9791eb936235a3567cc31447ae4"
-dependencies = [
- "itoa",
- "memchr",
- "serde",
- "serde_core",
- "zmij",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.111"
@@ -604,9 +547,3 @@ dependencies = [
  "quote",
  "syn",
 ]
-
-[[package]]
-name = "zmij"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1dccf46b25b205e4bebe1d5258a991df1cc17801017a845cb5b3fe0269781aa"

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

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

netrun_sim-0.1.2/core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "netrun-sim"
+description = "A flow-based development (FBD) simulation engine."
+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.0 → 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, EdgeRef, 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,53 +209,66 @@ 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(),
     }
 }
 
-fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> (EdgeRef, Edge) {
-    (
-        EdgeRef {
-            source: PortRef {
-                node_name: src_node.to_string(),
-                port_type: PortType::Output,
-                port_name: src_port.to_string(),
-            },
-            target: PortRef {
-                node_name: tgt_node.to_string(),
-                port_type: PortType::Input,
-                port_name: tgt_port.to_string(),
-            },
+fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> Edge {
+    Edge {
+        source: PortRef {
+            node_name: src_node.to_string(),
+            port_type: PortType::Output,
+            port_name: src_port.to_string(),
         },
-        Edge {},
-    )
+        target: PortRef {
+            node_name: tgt_node.to_string(),
+            port_type: PortType::Input,
+            port_name: tgt_port.to_string(),
+        },
+    }
 }
 
 fn edge_location(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> PacketLocation {
-    PacketLocation::Edge(EdgeRef {
+    PacketLocation::Edge(Edge {
         source: PortRef {
             node_name: src_node.to_string(),
             port_type: PortType::Output,
@@ -223,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.0 → 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, EdgeRef, 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)) {
@@ -34,7 +34,7 @@ fn main() {
     };
 
     // Transport packet to the edge A -> B
-    let edge_a_b = PacketLocation::Edge(EdgeRef {
+    let edge_a_b = PacketLocation::Edge(Edge {
         source: PortRef {
             node_name: "A".to_string(),
             port_type: PortType::Output,
@@ -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,
@@ -174,20 +207,17 @@ fn create_node(name: &str, in_ports: Vec<&str>, out_ports: Vec<&str>) -> Node {
     }
 }
 
-fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> (EdgeRef, Edge) {
-    (
-        EdgeRef {
-            source: PortRef {
-                node_name: src_node.to_string(),
-                port_type: PortType::Output,
-                port_name: src_port.to_string(),
-            },
-            target: PortRef {
-                node_name: tgt_node.to_string(),
-                port_type: PortType::Input,
-                port_name: tgt_port.to_string(),
-            },
+fn create_edge(src_node: &str, src_port: &str, tgt_node: &str, tgt_port: &str) -> Edge {
+    Edge {
+        source: PortRef {
+            node_name: src_node.to_string(),
+            port_type: PortType::Output,
+            port_name: src_port.to_string(),
         },
-        Edge {},
-    )
+        target: PortRef {
+            node_name: tgt_node.to_string(),
+            port_type: PortType::Input,
+            port_name: tgt_port.to_string(),
+        },
+    }
 }