changes

Author: rchac

src/rust/Cargo.lock

@@ -79,7 +79,7 @@ sysinfo = { version = "0", default-features = false, features = [ "system" ] }
 default-net = "0"
 reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "rustls-no-provider", "charset", "http2", "system-proxy"] }
 rustls = "0.23"
-pyo3 = "0.25.1"
+pyo3 = "0.29.0"
 colored = "2"
 miniz_oxide = "0.8"
 byteorder = "1"

src/rust/Cargo.toml

@@ -37,7 +37,7 @@ pub struct DeviceWeightRequest {
 /// This struct is used to receive a response from the Long Term Stats API
 /// It contains the circuit_id and the weight of the device
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[pyclass]
+#[pyclass(skip_from_py_object)]
 pub struct DeviceWeightResponse {
     #[pyo3(get)]
     pub circuit_id: String,

src/rust/lqos_python/src/device_weights.rs

@@ -36,6 +36,8 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
+type PyObject = Py<PyAny>;
+
 // ===== Planner CBOR I/O =====
 
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
@@ -166,11 +168,11 @@ fn plan_top_level_cpu_bins(
     hysteresis_threshold: Option<f64>,
 ) -> PyResult<PyObject> {
     let items_any = items.bind(py);
-    let items_list = items_any.downcast::<PyList>()?;
+    let items_list = items_any.cast::<PyList>()?;
     let planner_items: Vec<lqos_config::TopLevelPlannerItem> = items_list
         .iter()
         .map(|item| -> PyResult<lqos_config::TopLevelPlannerItem> {
-            let dict = item.downcast::<PyDict>()?;
+            let dict = item.cast::<PyDict>()?;
             let id = get_string(dict, "id", String::new());
             let weight = get_f64(dict, "weight", 1.0);
             Ok(lqos_config::TopLevelPlannerItem { id, weight })
@@ -180,7 +182,7 @@ fn plan_top_level_cpu_bins(
     let prev_assign_map = match prev_assign {
         Some(obj) => {
             let any = obj.bind(py);
-            let dict = any.downcast::<PyDict>()?;
+            let dict = any.cast::<PyDict>()?;
             dict.iter()
                 .filter_map(|(k, v)| {
                     Some((k.extract::<String>().ok()?, v.extract::<String>().ok()?))
@@ -192,7 +194,7 @@ fn plan_top_level_cpu_bins(
     let last_change_map = match last_change_ts {
         Some(obj) => {
             let any = obj.bind(py);
-            let dict = any.downcast::<PyDict>()?;
+            let dict = any.cast::<PyDict>()?;
             dict.iter()
                 .filter_map(|(k, v)| Some((k.extract::<String>().ok()?, v.extract::<f64>().ok()?)))
                 .collect::<BTreeMap<_, _>>()
@@ -258,11 +260,11 @@ fn plan_class_identities(
     stick_offset: u16,
     circuit_padding: u32,
 ) -> PyResult<PyObject> {
-    let sites_list = sites.bind(py).downcast::<PyList>()?;
+    let sites_list = sites.bind(py).cast::<PyList>()?;
     let site_inputs: Vec<lqos_config::SiteIdentityInput> = sites_list
         .iter()
         .map(|item| -> PyResult<lqos_config::SiteIdentityInput> {
-            let dict = item.downcast::<PyDict>()?;
+            let dict = item.cast::<PyDict>()?;
             Ok(lqos_config::SiteIdentityInput {
                 site_key: get_string(dict, "site_key", String::new()),
                 parent_path: get_string(dict, "parent_path", String::new()),
@@ -272,14 +274,14 @@ fn plan_class_identities(
         })
         .collect::<PyResult<Vec<_>>>()?;
 
-    let groups_list = circuit_groups.bind(py).downcast::<PyList>()?;
+    let groups_list = circuit_groups.bind(py).cast::<PyList>()?;
     let circuit_group_inputs: Vec<lqos_config::CircuitIdentityGroupInput> = groups_list
         .iter()
         .map(|item| -> PyResult<lqos_config::CircuitIdentityGroupInput> {
-            let dict = item.downcast::<PyDict>()?;
+            let dict = item.cast::<PyDict>()?;
             let ids = match dict.get_item("circuit_ids")? {
                 Some(value) => value
-                    .downcast::<PyList>()?
+                    .cast::<PyList>()?
                     .iter()
                     .filter_map(|entry| entry.extract::<String>().ok())
                     .collect::<Vec<_>>(),
@@ -295,11 +297,11 @@ fn plan_class_identities(
 
     let previous_sites = match site_state {
         Some(obj) => {
-            let dict = obj.bind(py).downcast::<PyDict>()?;
+            let dict = obj.bind(py).cast::<PyDict>()?;
             dict.iter()
                 .filter_map(|(k, v)| {
                     let key = k.extract::<String>().ok()?;
-                    let entry = v.downcast::<PyDict>().ok()?;
+                    let entry = v.cast::<PyDict>().ok()?;
                     Some((
                         key,
                         lqos_config::PlannerSiteIdentityState {
@@ -318,11 +320,11 @@ fn plan_class_identities(
 
     let previous_circuits = match circuit_state {
         Some(obj) => {
-            let dict = obj.bind(py).downcast::<PyDict>()?;
+            let dict = obj.bind(py).cast::<PyDict>()?;
             dict.iter()
                 .filter_map(|(k, v)| {
                     let key = k.extract::<String>().ok()?;
-                    let entry = v.downcast::<PyDict>().ok()?;
+                    let entry = v.cast::<PyDict>().ok()?;
                     Some((
                         key,
                         lqos_config::PlannerCircuitIdentityState {
@@ -411,7 +413,7 @@ fn plan_class_identities(
 fn write_planner_cbor(py: Python, path: String, state: PyObject) -> PyResult<bool> {
     use std::fs;
     use std::io::Write;
-    let dict = state.downcast_bound::<pyo3::types::PyDict>(py)?;
+    let dict = state.cast_bound::<pyo3::types::PyDict>(py)?;
     // Build strongly typed struct, preserving integer keys
     let algo_version = get_string(dict, "algo_version", default_algo_version());
     let updated_at = get_f64(dict, "updated_at", 0.0);
@@ -420,7 +422,7 @@ fn write_planner_cbor(py: Python, path: String, state: PyObject) -> PyResult<boo
     let site_count = get_i64(dict, "site_count", 0);
     let mut site_names: Vec<i64> = Vec::new();
     if let Ok(Some(sn)) = dict.get_item("site_names")
-        && let Ok(list) = sn.downcast::<pyo3::types::PyList>()
+        && let Ok(list) = sn.cast::<pyo3::types::PyList>()
     {
         for item in list.iter() {
             if let Some(n) = to_i64_any(&item) {
@@ -431,11 +433,11 @@ fn write_planner_cbor(py: Python, path: String, state: PyObject) -> PyResult<boo
     // site_map
     let mut site_map: BTreeMap<i64, PlannerSiteEntry> = BTreeMap::new();
     if let Ok(Some(sm_any)) = dict.get_item("site_map")
-        && let Ok(sm_dict) = sm_any.downcast::<pyo3::types::PyDict>()
+        && let Ok(sm_dict) = sm_any.cast::<pyo3::types::PyDict>()
     {
         for (k, v) in sm_dict.iter() {
             if let Some(key) = to_i64_any(&k)
-                && let Ok(entry) = v.downcast::<pyo3::types::PyDict>()
+                && let Ok(entry) = v.cast::<pyo3::types::PyDict>()
             {
                 let cpu = get_i64(entry, "cpu", 0);
                 let major = get_i64(entry, "major", 0);
@@ -459,11 +461,11 @@ fn write_planner_cbor(py: Python, path: String, state: PyObject) -> PyResult<boo
     // circuit_map
     let mut circuit_map: BTreeMap<i64, PlannerCircuitEntry> = BTreeMap::new();
     if let Ok(Some(cm_any)) = dict.get_item("circuit_map")
-        && let Ok(cm_dict) = cm_any.downcast::<pyo3::types::PyDict>()
+        && let Ok(cm_dict) = cm_any.cast::<pyo3::types::PyDict>()
     {
         for (k, v) in cm_dict.iter() {
             if let Some(key) = to_i64_any(&k)
-                && let Ok(entry) = v.downcast::<pyo3::types::PyDict>()
+                && let Ok(entry) = v.cast::<pyo3::types::PyDict>()
             {
                 let cpu = get_i64(entry, "cpu", 0);
                 let major = get_i64(entry, "major", 0);
@@ -740,7 +742,7 @@ fn fetch_planner_remote(
 #[pyfunction]
 fn store_planner_remote(py: Python, state: PyObject) -> PyResult<bool> {
     // Extract needed values and serialize as compressed CBOR
-    let dict = state.downcast_bound::<pyo3::types::PyDict>(py)?;
+    let dict = state.cast_bound::<pyo3::types::PyDict>(py)?;
     let algo_version = get_string(dict, "algo_version", default_algo_version());
     let updated_at = get_f64(dict, "updated_at", 0.0);
     let queues_available = get_i64(dict, "queuesAvailable", 0);
@@ -749,7 +751,7 @@ fn store_planner_remote(py: Python, state: PyObject) -> PyResult<bool> {
     // site_names
     let mut site_names: Vec<i64> = Vec::new();
     if let Ok(Some(sn)) = dict.get_item("site_names")
-        && let Ok(list) = sn.downcast::<pyo3::types::PyList>()
+        && let Ok(list) = sn.cast::<pyo3::types::PyList>()
     {
         for item in list.iter() {
             if let Some(n) = to_i64_any(&item) {
@@ -760,11 +762,11 @@ fn store_planner_remote(py: Python, state: PyObject) -> PyResult<bool> {
     // site_map
     let mut site_map: BTreeMap<i64, PlannerSiteEntry> = BTreeMap::new();
     if let Ok(Some(sm_any)) = dict.get_item("site_map")
-        && let Ok(sm_dict) = sm_any.downcast::<pyo3::types::PyDict>()
+        && let Ok(sm_dict) = sm_any.cast::<pyo3::types::PyDict>()
     {
         for (k, v) in sm_dict.iter() {
             if let Some(key) = to_i64_any(&k)
-                && let Ok(entry) = v.downcast::<pyo3::types::PyDict>()
+                && let Ok(entry) = v.cast::<pyo3::types::PyDict>()
             {
                 let cpu = get_i64(entry, "cpu", 0);
                 let major = get_i64(entry, "major", 0);
@@ -788,11 +790,11 @@ fn store_planner_remote(py: Python, state: PyObject) -> PyResult<bool> {
     // circuit_map
     let mut circuit_map: BTreeMap<i64, PlannerCircuitEntry> = BTreeMap::new();
     if let Ok(Some(cm_any)) = dict.get_item("circuit_map")
-        && let Ok(cm_dict) = cm_any.downcast::<pyo3::types::PyDict>()
+        && let Ok(cm_dict) = cm_any.cast::<pyo3::types::PyDict>()
     {
         for (k, v) in cm_dict.iter() {
             if let Some(key) = to_i64_any(&k)
-                && let Ok(entry) = v.downcast::<pyo3::types::PyDict>()
+                && let Ok(entry) = v.cast::<pyo3::types::PyDict>()
             {
                 let cpu = get_i64(entry, "cpu", 0);
                 let major = get_i64(entry, "major", 0);

src/rust/lqos_python/src/lib.rs

@@ -2757,12 +2757,16 @@ fn resolved_auto_queue_visibility_policy(
     if !queue_auto_node_kind_can_hide(tree_node) {
         return TopologyQueueVisibilityPolicy::QueueVisible;
     }
-    if child_branch_counts
+    let logical_child_count = child_branch_counts
         .get(ui_node.node_id.as_str())
         .copied()
-        .unwrap_or_default()
-        == 0
-    {
+        .unwrap_or_default();
+    let effective_child_count = tree_node
+        .get("children")
+        .and_then(Value::as_object)
+        .map(Map::len)
+        .unwrap_or_default();
+    if logical_child_count == 0 && effective_child_count == 0 {
         return TopologyQueueVisibilityPolicy::QueueVisible;
     }
     let threshold = config.topology.queue_auto_virtualize_threshold_mbps;
@@ -7036,6 +7040,36 @@ mod tests {
         assert!(aggregation_children.get("Access AP").is_some());
     }
 
+    #[test]
+    fn queue_auto_marks_large_ap_branch_virtual_with_effective_tree_children() {
+        let (config, canonical, mut editor_state, effective) = ap_branch_fixture();
+        let access_ap = editor_state
+            .nodes
+            .iter_mut()
+            .find(|node| node.node_id == "ap-child")
+            .expect("fixture should include Access AP");
+        access_ap.current_parent_node_id = Some("site-root".to_string());
+        access_ap.current_parent_node_name = Some("Core".to_string());
+
+        let effective_network = apply_effective_topology_to_network_json(
+            &config,
+            &canonical,
+            &editor_state,
+            &effective,
+        );
+        let root = effective_network
+            .as_object()
+            .expect("effective export should remain an object tree");
+        let aggregation = root["Core"]["children"]["Aggregation Switch"]
+            .as_object()
+            .expect("Aggregation Switch should remain visible as a virtual node");
+
+        assert_eq!(
+            aggregation.get("virtual").and_then(Value::as_bool),
+            Some(true)
+        );
+    }
+
     #[test]
     fn queue_auto_keeps_large_ap_branch_visible_with_direct_circuit() {
         let (config, canonical, editor_state, effective) = ap_branch_fixture();