rosotacom-dev 2.5.dev38__tar.gz → 2.5.dev40__tar.gz

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev38
+Version: 2.5.dev40
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/session-configuration.md

@@ -446,7 +446,8 @@ processing:
   pixel_cap_preset: "wsvga"       # scalar, used as suffix only,
   transport:
     type: ffmpeg                  # ffmpeg | foxglove | compressed
-    local_republish: false        # default false
+    local_republish: raw          # raw | compressed; omit for no sender-side decode
+    remote_republish: compressed  # raw | compressed; omit for no receiver-side decode
     # plus type-specific params (see below)
 ```
 
@@ -507,11 +508,37 @@ The receiver undoes the chain in reverse, and every stage there is computed from
 the delivered topic rather than from the OTA topic:
 
 1) unwrap → republishes on the pre-wrap name (so wrapping renames nothing)
-2) `local_republish: true` → reverse transport decodes into `+ /raw`
+2) `remote_republish: <transport>` → reverse transport decodes into `+ /<transport>`
 3) decompress → republishes on the pre-compress name
 4) framebridge `global_to_local` → the local base topic
 5) trickle → `+ /trickle`, the only receiver-side stage that adds a suffix
 
+##### The two reverse republishes
+
+An encoded stream crosses the link as packets — `FFMPEGPacket`, `CompressedVideo`
+— and something has to turn those back into an image. That decode can happen in
+two places, and they answer different questions:
+
+- **`remote_republish`** runs on the receiving peer and is the one that matters:
+  it produces the topic the receiving application subscribes to (`<encoded>/raw`
+  or `<encoded>/compressed`), and it is what `_delivered_topic` reports as the
+  delivered stage.
+- **`local_republish`** runs on the *sending* peer, against the stream it just
+  encoded. Nothing crosses the link for it; it exists so the sending machine can
+  see approximately what the receiver will get.
+
+Both name the image transport they publish in rather than being switched on:
+
+| value | delivered type | cost |
+|---|---|---|
+| `raw` | `sensor_msgs/msg/Image` | the transport undone and nothing else, at full frame size — a 1280x800 stream is ~3 MB per frame |
+| `compressed` | `sensor_msgs/msg/CompressedImage` | a JPEG encode per frame, roughly an order of magnitude less data on the wire and in a `record -a` |
+
+Omitting a key means that side does not decode. There is deliberately **no
+default**: `type: compressed` already delivers an image, so a decode that
+switched itself on would produce exactly the full-size copy a session chose that
+transport to avoid.
+
 #### Transport parameters
 `type: ffmpeg` supports:
 - `gop_size` (int)

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/cli.py

@@ -6134,8 +6134,11 @@ def _smoke_postprocessed_topic(entry: Any, pipe: dict[str, Any]) -> str:
     if pipe.get("framebridge") == "global_to_local":
         return str(pipe["fb_g2l_base"])
     transport = pipe.get("transport")
-    if transport is not None and bool(getattr(transport, "local_republish", False)):
-        return str(pipe["final"]) + "/raw"
+    remote_republish = getattr(transport, "remote_republish", None) if transport is not None else None
+    if remote_republish:
+        # The receiver's decode is what the smoke drives and asserts; the
+        # sender's own preview (`local_republish`) never reaches this peer.
+        return str(pipe["final"]) + f"/{remote_republish}"
     return str(pipe["final"])
 
 

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/resources/examples/sessions/17_synthetic_camera_quality/session-definition.yaml

@@ -49,7 +49,11 @@ topics:
       processing:
         transport:
           type: ffmpeg
-          local_republish: true
+          # `raw` on both sides, because this example measures the codec: PSNR
+          # and SSIM compare pixels, and a JPEG twin would fold its own loss
+          # into the number the example exists to report.
+          local_republish: raw
+          remote_republish: raw
           gop_size: 4
           bit_rate: 2000000
         # Wrapping an encoded stream: the wrapper runs after the encoder, so the

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/resources/ws/ros2src/com_py/com_py/base_bridge_relay.py

@@ -61,8 +61,8 @@ class BaseBridgeRelay(Node, PairRefreshMixin):
         self.qos_config_file = self.declare_parameter('qos_config_file', '').value
 
         # Optional parameters with defaults
-        self.source_names = self.declare_parameter('source_names', rclpy.Parameter.Type.STRING_ARRAY).value or []
-        self.target_names = self.declare_parameter('target_names', rclpy.Parameter.Type.STRING_ARRAY).value or []
+        self.source_names = self.declare_optional_string_array('source_names')
+        self.target_names = self.declare_optional_string_array('target_names')
 
         # Derived classes can declare additional parameters here (must happen before initialize_node()).
         self.declare_additional_parameters()
@@ -73,6 +73,36 @@ class BaseBridgeRelay(Node, PairRefreshMixin):
         # Create timer for periodic refresh of invalid pairs
         self.init_pair_refresh(period_s=5.0, log_prefix=self.node_role)
 
+    def declare_optional_string_array(self, name: str) -> list:
+        """Declare an optional STRING_ARRAY that reads as [] rather than as unset.
+
+        Declaring a type without a value leaves the parameter
+        PARAMETER_NOT_SET. This node never notices — it reads the value once,
+        here, and an unset parameter simply yields None. Everything *else*
+        notices: reading a not-set parameter raises, and rclpy's parameter
+        service logs one warning per read against this node,
+
+            [WARN] [ota_relay_out]: Failed to get parameters: The parameter
+            'source_names' is not initialized: source_names
+
+        which anything that enumerates parameters then produces on a timer. A
+        Foxglove bridge with a parameter panel open put 107 of those lines into
+        a single pane in one session — the kind of noise that hides the message
+        somebody actually needs to see.
+
+        A plain default cannot express this: `declare_parameter(name, [])`
+        infers the type from the value, and an empty list satisfies the
+        BYTE_ARRAY test first (`all(...)` is true for an empty sequence). The
+        parameter would be typed BYTE_ARRAY and the real string array refused
+        later with "Wrong parameter type, expected '5' got '9'". Declaring the
+        type and then setting the empty value keeps it STRING_ARRAY, so a wrong
+        type is still rejected and an override still wins.
+        """
+        self.declare_parameter(name, rclpy.Parameter.Type.STRING_ARRAY)
+        if self.get_parameter_or(name).type_ == rclpy.Parameter.Type.NOT_SET:
+            self.set_parameters([rclpy.Parameter(name, rclpy.Parameter.Type.STRING_ARRAY, [])])
+        return self.get_parameter(name).value
+
     def initialize_node(self):
         """Initialize node with resolved topics and QoS configuration."""
         try:

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/resources/ws/ros2src/com_py/com_py/qos.py

@@ -139,7 +139,13 @@ def get_topic_qos(logger, qos_config: dict, topic_name: str, role_name: str):
     Additionally supports a fallback lookup: if no exact match for topic_name exists
     in qos_config['topics'], we look for the most specific configured base topic key
     that matches as a path segment within topic_name (e.g. '/tf' for
-    '/shuttle_ella/tf/restamped'). If such a fallback is used, it is always logged.
+    '/shuttle_ella/tf/restamped'). Such a fallback is logged at debug level: it is
+    the designed path, not a degradation. Every processing stage appends a suffix,
+    so a session that uses framebridge, latching or a transport reaches it for most
+    of its topics, and a definition that declares QoS on the base topic and lets the
+    processed names inherit it is doing exactly what the schema intends. Logged as a
+    warning it was two lines per topic per peer at every start — enough noise around
+    a bring-up to bury an actual fault.
     """
     default = qos_config.get('default', {})
 
@@ -151,7 +157,7 @@ def get_topic_qos(logger, qos_config: dict, topic_name: str, role_name: str):
     if topic_name not in topics_cfg:
         base_match = _find_best_base_topic_match(topics_cfg, topic_name)
         if base_match is not None:
-            logger.warning(
+            logger.debug(
                 f"[dds_qos] No exact QoS match for topic='{topic_name}'. "
                 f"Falling back to base topic='{base_match}'."
             )

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/resources/ws/session/content/base/session_plugin_base.yaml

@@ -534,6 +534,19 @@ windows:
       - commands:
         - if [ '${ipx_4_topics}' = "None" ]; then exit; fi
         - ros2 run com_py image_pixel_capper --ros-args -p topics:=[${ipx_4_topics}] -p max_pixels_preset:=${ipx_4_preset} -p qos_config_file:='${qos_config_file}'
+  # `if ...; then ...; fi`, never `[[ ... ]] && ...`, for the optional argument
+  # lines below. catmux sends every one of these to an interactive shell, and
+  # `catmux_log_setup.sh` hooks the pane-exit recorder into PROMPT_COMMAND — so
+  # it sees the status of each line, not just of the node the pane finally runs.
+  # `&&` short-circuits to status 1 whenever the option is unset, which is the
+  # normal case for every option a session does not override, so each of these
+  # lines wrote itself into `pane_failures.log` as a dead pane:
+  #
+  #   pane=13-IT/0	exit=1	command=[[ "None" != "None" ]] && args+=(-p "ut.foxglove.bit_rate:=None")
+  #
+  # A peer then reported `STARTUP CHECK FAILED ... 4 pane(s) exited` on every
+  # start while nothing was wrong, which is the one thing that check must not
+  # do: it exists to make a genuinely dead pane visible in seconds.
   - name: IT
     if: it
     layout: even-vertical
@@ -542,15 +555,15 @@ windows:
         - if [ '${it_1_topic}' = "None" ]; then exit; fi
         - if [[ "${it_1_topic}" == *"/compressed"* ]]; then it_in_transport="compressed"; else it_in_transport="raw"; fi
         - args=(ros2 run image_transport republish --ros-args -r __node:=republish1 -p in_transport:=${it_in_transport})
-        - '[[ "${it_1_transport}" != "None" ]] && args+=(-p "out_transport:=${it_1_transport}")'
-        - '[[ "${it_1_compressed_jpeg_quality}" != "None" ]] && args+=(-p "ut.compressed.jpeg_quality:=${it_1_compressed_jpeg_quality}")'
-        - '[[ "${it_1_ffmpeg_gop_size}" != "None" ]] && args+=(-p "ut.ffmpeg.gop_size:=${it_1_ffmpeg_gop_size}")'
-        - '[[ "${it_1_ffmpeg_encoder_av_options}" != "None" ]] && args+=(-p "ut.ffmpeg.encoder_av_options:=${it_1_ffmpeg_encoder_av_options}")'
-        - '[[ "${it_1_ffmpeg_bit_rate}" != "None" ]] && args+=(-p "ut.ffmpeg.bit_rate:=${it_1_ffmpeg_bit_rate}")'
-        - '[[ "${it_1_foxglove_gop_size}" != "None" ]] && args+=(-p "ut.foxglove.gop_size:=${it_1_foxglove_gop_size}")'
-        - '[[ "${it_1_foxglove_encoder_av_options}" != "None" ]] && args+=(-p "ut.foxglove.encoder_av_options:=${it_1_foxglove_encoder_av_options}")'
-        - '[[ "${it_1_foxglove_bit_rate}" != "None" ]] && args+=(-p "ut.foxglove.bit_rate:=${it_1_foxglove_bit_rate}")'
-        - '[[ "${it_1_foxglove_qmax}" != "None" ]] && args+=(-p "ut.foxglove.qmax:=${it_1_foxglove_qmax}")'
+        - 'if [[ "${it_1_transport}" != "None" ]]; then args+=(-p "out_transport:=${it_1_transport}"); fi'
+        - 'if [[ "${it_1_compressed_jpeg_quality}" != "None" ]]; then args+=(-p "ut.compressed.jpeg_quality:=${it_1_compressed_jpeg_quality}"); fi'
+        - 'if [[ "${it_1_ffmpeg_gop_size}" != "None" ]]; then args+=(-p "ut.ffmpeg.gop_size:=${it_1_ffmpeg_gop_size}"); fi'
+        - 'if [[ "${it_1_ffmpeg_encoder_av_options}" != "None" ]]; then args+=(-p "ut.ffmpeg.encoder_av_options:=${it_1_ffmpeg_encoder_av_options}"); fi'
+        - 'if [[ "${it_1_ffmpeg_bit_rate}" != "None" ]]; then args+=(-p "ut.ffmpeg.bit_rate:=${it_1_ffmpeg_bit_rate}"); fi'
+        - 'if [[ "${it_1_foxglove_gop_size}" != "None" ]]; then args+=(-p "ut.foxglove.gop_size:=${it_1_foxglove_gop_size}"); fi'
+        - 'if [[ "${it_1_foxglove_encoder_av_options}" != "None" ]]; then args+=(-p "ut.foxglove.encoder_av_options:=${it_1_foxglove_encoder_av_options}"); fi'
+        - 'if [[ "${it_1_foxglove_bit_rate}" != "None" ]]; then args+=(-p "ut.foxglove.bit_rate:=${it_1_foxglove_bit_rate}"); fi'
+        - 'if [[ "${it_1_foxglove_qmax}" != "None" ]]; then args+=(-p "ut.foxglove.qmax:=${it_1_foxglove_qmax}"); fi'
         - if [[ "${it_1_outgoing_suffix}" != "None" ]]; then outgoing_suffix="${it_1_outgoing_suffix}"; else outgoing_suffix="${it_1_transport}"; fi
         - if [[ "${it_in_transport}" == "raw" ]]; then in_remap="in"; else in_remap="in/${it_in_transport}"; fi
         - args+=(--remap "${in_remap}:=${it_1_topic}" --remap "out/${it_1_transport}:=${it_1_topic}/${outgoing_suffix}")
@@ -560,15 +573,15 @@ windows:
         - if [ '${it_2_topic}' = "None" ]; then exit; fi
         - if [[ "${it_2_topic}" == *"/compressed"* ]]; then it_in_transport="compressed"; else it_in_transport="raw"; fi
         - args=(ros2 run image_transport republish --ros-args -r __node:=republish2 -p in_transport:=${it_in_transport})
-        - '[[ "${it_2_transport}" != "None" ]] && args+=(-p "out_transport:=${it_2_transport}")'
-        - '[[ "${it_2_compressed_jpeg_quality}" != "None" ]] && args+=(-p "ut.compressed.jpeg_quality:=${it_2_compressed_jpeg_quality}")'
-        - '[[ "${it_2_ffmpeg_gop_size}" != "None" ]] && args+=(-p "ut.ffmpeg.gop_size:=${it_2_ffmpeg_gop_size}")'
-        - '[[ "${it_2_ffmpeg_encoder_av_options}" != "None" ]] && args+=(-p "ut.ffmpeg.encoder_av_options:=${it_2_ffmpeg_encoder_av_options}")'
-        - '[[ "${it_2_ffmpeg_bit_rate}" != "None" ]] && args+=(-p "ut.ffmpeg.bit_rate:=${it_2_ffmpeg_bit_rate}")'
-        - '[[ "${it_2_foxglove_gop_size}" != "None" ]] && args+=(-p "ut.foxglove.gop_size:=${it_2_foxglove_gop_size}")'
-        - '[[ "${it_2_foxglove_encoder_av_options}" != "None" ]] && args+=(-p "ut.foxglove.encoder_av_options:=${it_2_foxglove_encoder_av_options}")'
-        - '[[ "${it_2_foxglove_bit_rate}" != "None" ]] && args+=(-p "ut.foxglove.bit_rate:=${it_2_foxglove_bit_rate}")'
-        - '[[ "${it_2_foxglove_qmax}" != "None" ]] && args+=(-p "ut.foxglove.qmax:=${it_2_foxglove_qmax}")'
+        - 'if [[ "${it_2_transport}" != "None" ]]; then args+=(-p "out_transport:=${it_2_transport}"); fi'
+        - 'if [[ "${it_2_compressed_jpeg_quality}" != "None" ]]; then args+=(-p "ut.compressed.jpeg_quality:=${it_2_compressed_jpeg_quality}"); fi'
+        - 'if [[ "${it_2_ffmpeg_gop_size}" != "None" ]]; then args+=(-p "ut.ffmpeg.gop_size:=${it_2_ffmpeg_gop_size}"); fi'
+        - 'if [[ "${it_2_ffmpeg_encoder_av_options}" != "None" ]]; then args+=(-p "ut.ffmpeg.encoder_av_options:=${it_2_ffmpeg_encoder_av_options}"); fi'
+        - 'if [[ "${it_2_ffmpeg_bit_rate}" != "None" ]]; then args+=(-p "ut.ffmpeg.bit_rate:=${it_2_ffmpeg_bit_rate}"); fi'
+        - 'if [[ "${it_2_foxglove_gop_size}" != "None" ]]; then args+=(-p "ut.foxglove.gop_size:=${it_2_foxglove_gop_size}"); fi'
+        - 'if [[ "${it_2_foxglove_encoder_av_options}" != "None" ]]; then args+=(-p "ut.foxglove.encoder_av_options:=${it_2_foxglove_encoder_av_options}"); fi'
+        - 'if [[ "${it_2_foxglove_bit_rate}" != "None" ]]; then args+=(-p "ut.foxglove.bit_rate:=${it_2_foxglove_bit_rate}"); fi'
+        - 'if [[ "${it_2_foxglove_qmax}" != "None" ]]; then args+=(-p "ut.foxglove.qmax:=${it_2_foxglove_qmax}"); fi'
         - if [[ "${it_2_outgoing_suffix}" != "None" ]]; then outgoing_suffix="${it_2_outgoing_suffix}"; else outgoing_suffix="${it_2_transport}"; fi
         - if [[ "${it_in_transport}" == "raw" ]]; then in_remap="in"; else in_remap="in/${it_in_transport}"; fi
         - args+=(--remap "${in_remap}:=${it_2_topic}" --remap "out/${it_2_transport}:=${it_2_topic}/${outgoing_suffix}")
@@ -578,15 +591,15 @@ windows:
         - if [ '${it_3_topic}' = "None" ]; then exit; fi
         - if [[ "${it_3_topic}" == *"/compressed"* ]]; then it_in_transport="compressed"; else it_in_transport="raw"; fi
         - args=(ros2 run image_transport republish --ros-args -r __node:=republish3 -p in_transport:=${it_in_transport})
-        - '[[ "${it_3_transport}" != "None" ]] && args+=(-p "out_transport:=${it_3_transport}")'
-        - '[[ "${it_3_compressed_jpeg_quality}" != "None" ]] && args+=(-p "ut.compressed.jpeg_quality:=${it_3_compressed_jpeg_quality}")'
-        - '[[ "${it_3_ffmpeg_gop_size}" != "None" ]] && args+=(-p "ut.ffmpeg.gop_size:=${it_3_ffmpeg_gop_size}")'
-        - '[[ "${it_3_ffmpeg_encoder_av_options}" != "None" ]] && args+=(-p "ut.ffmpeg.encoder_av_options:=${it_3_ffmpeg_encoder_av_options}")'
-        - '[[ "${it_3_ffmpeg_bit_rate}" != "None" ]] && args+=(-p "ut.ffmpeg.bit_rate:=${it_3_ffmpeg_bit_rate}")'
-        - '[[ "${it_3_foxglove_gop_size}" != "None" ]] && args+=(-p "ut.foxglove.gop_size:=${it_3_foxglove_gop_size}")'
-        - '[[ "${it_3_foxglove_encoder_av_options}" != "None" ]] && args+=(-p "ut.foxglove.encoder_av_options:=${it_3_foxglove_encoder_av_options}")'
-        - '[[ "${it_3_foxglove_bit_rate}" != "None" ]] && args+=(-p "ut.foxglove.bit_rate:=${it_3_foxglove_bit_rate}")'
-        - '[[ "${it_3_foxglove_qmax}" != "None" ]] && args+=(-p "ut.foxglove.qmax:=${it_3_foxglove_qmax}")'
+        - 'if [[ "${it_3_transport}" != "None" ]]; then args+=(-p "out_transport:=${it_3_transport}"); fi'
+        - 'if [[ "${it_3_compressed_jpeg_quality}" != "None" ]]; then args+=(-p "ut.compressed.jpeg_quality:=${it_3_compressed_jpeg_quality}"); fi'
+        - 'if [[ "${it_3_ffmpeg_gop_size}" != "None" ]]; then args+=(-p "ut.ffmpeg.gop_size:=${it_3_ffmpeg_gop_size}"); fi'
+        - 'if [[ "${it_3_ffmpeg_encoder_av_options}" != "None" ]]; then args+=(-p "ut.ffmpeg.encoder_av_options:=${it_3_ffmpeg_encoder_av_options}"); fi'
+        - 'if [[ "${it_3_ffmpeg_bit_rate}" != "None" ]]; then args+=(-p "ut.ffmpeg.bit_rate:=${it_3_ffmpeg_bit_rate}"); fi'
+        - 'if [[ "${it_3_foxglove_gop_size}" != "None" ]]; then args+=(-p "ut.foxglove.gop_size:=${it_3_foxglove_gop_size}"); fi'
+        - 'if [[ "${it_3_foxglove_encoder_av_options}" != "None" ]]; then args+=(-p "ut.foxglove.encoder_av_options:=${it_3_foxglove_encoder_av_options}"); fi'
+        - 'if [[ "${it_3_foxglove_bit_rate}" != "None" ]]; then args+=(-p "ut.foxglove.bit_rate:=${it_3_foxglove_bit_rate}"); fi'
+        - 'if [[ "${it_3_foxglove_qmax}" != "None" ]]; then args+=(-p "ut.foxglove.qmax:=${it_3_foxglove_qmax}"); fi'
         - if [[ "${it_3_outgoing_suffix}" != "None" ]]; then outgoing_suffix="${it_3_outgoing_suffix}"; else outgoing_suffix="${it_3_transport}"; fi
         - if [[ "${it_in_transport}" == "raw" ]]; then in_remap="in"; else in_remap="in/${it_in_transport}"; fi
         - args+=(--remap "${in_remap}:=${it_3_topic}" --remap "out/${it_3_transport}:=${it_3_topic}/${outgoing_suffix}")
@@ -596,15 +609,15 @@ windows:
         - if [ '${it_4_topic}' = "None" ]; then exit; fi
         - if [[ "${it_4_topic}" == *"/compressed"* ]]; then it_in_transport="compressed"; else it_in_transport="raw"; fi
         - args=(ros2 run image_transport republish --ros-args -r __node:=republish4 -p in_transport:=${it_in_transport})
-        - '[[ "${it_4_transport}" != "None" ]] && args+=(-p "out_transport:=${it_4_transport}")'
-        - '[[ "${it_4_compressed_jpeg_quality}" != "None" ]] && args+=(-p "ut.compressed.jpeg_quality:=${it_4_compressed_jpeg_quality}")'
-        - '[[ "${it_4_ffmpeg_gop_size}" != "None" ]] && args+=(-p "ut.ffmpeg.gop_size:=${it_4_ffmpeg_gop_size}")'
-        - '[[ "${it_4_ffmpeg_encoder_av_options}" != "None" ]] && args+=(-p "ut.ffmpeg.encoder_av_options:=${it_4_ffmpeg_encoder_av_options}")'
-        - '[[ "${it_4_ffmpeg_bit_rate}" != "None" ]] && args+=(-p "ut.ffmpeg.bit_rate:=${it_4_ffmpeg_bit_rate}")'
-        - '[[ "${it_4_foxglove_gop_size}" != "None" ]] && args+=(-p "ut.foxglove.gop_size:=${it_4_foxglove_gop_size}")'
-        - '[[ "${it_4_foxglove_encoder_av_options}" != "None" ]] && args+=(-p "ut.foxglove.encoder_av_options:=${it_4_foxglove_encoder_av_options}")'
-        - '[[ "${it_4_foxglove_bit_rate}" != "None" ]] && args+=(-p "ut.foxglove.bit_rate:=${it_4_foxglove_bit_rate}")'
-        - '[[ "${it_4_foxglove_qmax}" != "None" ]] && args+=(-p "ut.foxglove.qmax:=${it_4_foxglove_qmax}")'
+        - 'if [[ "${it_4_transport}" != "None" ]]; then args+=(-p "out_transport:=${it_4_transport}"); fi'
+        - 'if [[ "${it_4_compressed_jpeg_quality}" != "None" ]]; then args+=(-p "ut.compressed.jpeg_quality:=${it_4_compressed_jpeg_quality}"); fi'
+        - 'if [[ "${it_4_ffmpeg_gop_size}" != "None" ]]; then args+=(-p "ut.ffmpeg.gop_size:=${it_4_ffmpeg_gop_size}"); fi'
+        - 'if [[ "${it_4_ffmpeg_encoder_av_options}" != "None" ]]; then args+=(-p "ut.ffmpeg.encoder_av_options:=${it_4_ffmpeg_encoder_av_options}"); fi'
+        - 'if [[ "${it_4_ffmpeg_bit_rate}" != "None" ]]; then args+=(-p "ut.ffmpeg.bit_rate:=${it_4_ffmpeg_bit_rate}"); fi'
+        - 'if [[ "${it_4_foxglove_gop_size}" != "None" ]]; then args+=(-p "ut.foxglove.gop_size:=${it_4_foxglove_gop_size}"); fi'
+        - 'if [[ "${it_4_foxglove_encoder_av_options}" != "None" ]]; then args+=(-p "ut.foxglove.encoder_av_options:=${it_4_foxglove_encoder_av_options}"); fi'
+        - 'if [[ "${it_4_foxglove_bit_rate}" != "None" ]]; then args+=(-p "ut.foxglove.bit_rate:=${it_4_foxglove_bit_rate}"); fi'
+        - 'if [[ "${it_4_foxglove_qmax}" != "None" ]]; then args+=(-p "ut.foxglove.qmax:=${it_4_foxglove_qmax}"); fi'
         - if [[ "${it_4_outgoing_suffix}" != "None" ]]; then outgoing_suffix="${it_4_outgoing_suffix}"; else outgoing_suffix="${it_4_transport}"; fi
         - if [[ "${it_in_transport}" == "raw" ]]; then in_remap="in"; else in_remap="in/${it_in_transport}"; fi
         - args+=(--remap "${in_remap}:=${it_4_topic}" --remap "out/${it_4_transport}:=${it_4_topic}/${outgoing_suffix}")

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom/resources/ws/session/creation/generate_session_files.py

@@ -64,18 +64,34 @@ HEARTBEAT_MSG_TYPE = "com_msgs/msg/EchoHeartbeat"
 COMPRESSED_MSG_TYPE = "com_msgs/msg/CompressedData"
 OTA_STAMPED_MSG_TYPE = "com_msgs/msg/OtaStamped"
 SENSOR_IMAGE_MSG_TYPE = "sensor_msgs/msg/Image"
+SENSOR_COMPRESSED_IMAGE_MSG_TYPE = "sensor_msgs/msg/CompressedImage"
 TRANSPORT_OUTPUT_TYPES = {
     "compressed": "sensor_msgs/msg/CompressedImage",
     "ffmpeg": "ffmpeg_image_transport_msgs/msg/FFMPEGPacket",
     "foxglove": "foxglove_msgs/msg/CompressedVideo",
 }
+#: The image transports a reverse republish may decode *into*, and the message
+#: type each one delivers. `raw` is the neutral reconstruction -- the transport
+#: undone and nothing else -- and `compressed` trades a JPEG encode for roughly
+#: an order of magnitude less data on the wire and in a `record -a`.
+REPUBLISH_OUTPUT_TYPES = {
+    "raw": SENSOR_IMAGE_MSG_TYPE,
+    "compressed": SENSOR_COMPRESSED_IMAGE_MSG_TYPE,
+}
 
 
 @dataclass
 class TransportSpec:
     type: str
     params: Dict[str, Any]
-    local_republish: bool = False
+    #: Reverse republish on the sending peer: decode the stream it just encoded,
+    #: so the machine that sends can see what the receiver will get. Optional.
+    local_republish: Optional[str] = None
+    #: Reverse republish on the receiving peer: the decode the receiving
+    #: application consumes. Optional too -- a consumer that subscribes through
+    #: image_transport itself, or one that only forwards or records packets,
+    #: does not want a second copy of every frame.
+    remote_republish: Optional[str] = None
 
 
 @dataclass
@@ -1288,11 +1304,14 @@ def _delivered_topic(pipe: Dict[str, Any], final: str) -> str:
         # renames nothing downstream of it.
         topic = str(pipe["ota_in"])
     transport = pipe.get("transport")
-    if isinstance(transport, TransportSpec) and transport.local_republish:
-        # image_transport reverse republish decodes the encoded topic into
-        # `<encoded>/raw`; PSNR/SSIM and application-level checks need that
-        # decoded sensor_msgs/Image stage, not the encoded packet.
-        topic = str(pipe["irt_in"]) + "/raw"
+    if isinstance(transport, TransportSpec) and transport.remote_republish:
+        # The receiver's reverse republish decodes the encoded topic into
+        # `<encoded>/<transport>`, and that decoded image -- not the encoded
+        # packet -- is what the receiving application subscribes to.
+        # `local_republish` is deliberately not consulted here: it is the
+        # *sender's* preview, on the sender's machine, and says nothing about
+        # what the receiver ends up reading.
+        topic = str(pipe["irt_in"]) + f"/{transport.remote_republish}"
     elif pipe.get("compress"):
         topic = str(pipe["comp_in"])
     if pipe.get("framebridge") == "global_to_local":
@@ -1544,8 +1563,8 @@ def _build_status_pipeline_spec(
             if postprocessed != final:
                 native_in_type = base_type
                 transport = p.get("transport")
-                if isinstance(transport, TransportSpec) and transport.local_republish:
-                    native_in_type = SENSOR_IMAGE_MSG_TYPE
+                if isinstance(transport, TransportSpec) and transport.remote_republish:
+                    native_in_type = REPUBLISH_OUTPUT_TYPES[transport.remote_republish]
                 stages.append(
                     {
                         "stage": "native_in",
@@ -1659,9 +1678,27 @@ def _compute_pipeline(
         if not isinstance(t, dict) or "type" not in t:
             raise ValueError(f"transport must be dict with 'type' for topic '{entry.base}'")
         ttype = t["type"]
-        local_republish = bool(t.get("local_republish", False))
-        params = {k: v for k, v in t.items() if k not in ("type", "local_republish")}
-        transport = TransportSpec(type=ttype, params=params, local_republish=local_republish)
+        republish_keys = ("local_republish", "remote_republish")
+
+        def _republish(key: str) -> Optional[str]:
+            value = t.get(key)
+            if value is None:
+                return None
+            if value not in REPUBLISH_OUTPUT_TYPES:
+                raise ValueError(
+                    f"transport.{key} must name an image transport "
+                    f"({'|'.join(sorted(REPUBLISH_OUTPUT_TYPES))}) for topic '{entry.base}', got {value!r}. "
+                    "Omit the key for no reverse republish on that side."
+                )
+            return str(value)
+
+        params = {k: v for k, v in t.items() if k not in ("type", *republish_keys)}
+        transport = TransportSpec(
+            type=ttype,
+            params=params,
+            local_republish=_republish("local_republish"),
+            remote_republish=_republish("remote_republish"),
+        )
 
     topic = entry.base
 
@@ -1747,7 +1784,11 @@ def _compute_pipeline(
     if transport:
         it_in = topic
         topic = topic + f"/{transport.type}"
-        if transport.local_republish:
+        if transport.local_republish or transport.remote_republish:
+            # The encoded topic a reverse republish decodes *from*. One name for
+            # both sides: each peer runs its own decoder against the copy it has
+            # (the sender against what it just encoded, the receiver against what
+            # arrived), and which of them exists is decided per side below.
             irt_in = topic
 
     # The wrapper is last, always. Its `seq` and send stamp describe whatever it
@@ -2607,7 +2648,11 @@ def func(
         thr_items = [(p["thr_in"], p["throttle"]) for p in out_pipes if p["thr_in"]]
         ipx_items = [(p["ipx_in"], p["pixel"]) for p in out_pipes if p["ipx_in"]]
         it_items = [(p["it_in"], p["transport"]) for p in out_pipes if p["it_in"]]
-        irt_items_local = [(p["irt_in"], p["transport"]) for p in out_pipes if p["irt_in"]]
+        # Sender-side reverse transport: this peer decodes what it just encoded,
+        # so the machine that sends can see what the receiver will get.
+        irt_items_local = [
+            (p["irt_in"], p["transport"]) for p in out_pipes if p["irt_in"] and p["transport"].local_republish
+        ]
 
         # Compression happens on the sender side for topics marked with processing.compress
         comp_topics = _dedup_keep_order([p["comp_in"] for p in out_pipes if p["comp_in"]])
@@ -2660,15 +2705,15 @@ def func(
         _assert_max("it", it_items, 4)
         _assert_max("nor", nor_items, 4)
 
-        # Remote-side reverse transport is configured (if requested via local_republish) on the receiver, too.
+        # Receiver-side reverse transport: this peer decodes what arrived, which
+        # is the copy the receiving application reads (see `_delivered_topic`).
         irt_items_remote = []
         for e, p in zip(in_entries, in_pipes):
-            if not p["irt_in"]:
-                continue
             tspec = p["transport"]
-            assert tspec is not None
+            if not p["irt_in"] or not (tspec and tspec.remote_republish):
+                continue
             topic = _prefix_with_source_name_if_needed(local, remote, p["irt_in"])
-            irt_items_remote.append((topic, tspec.type))
+            irt_items_remote.append((topic, tspec))
 
         # Build plugin.yaml blocks
         blocks: List[PluginBlock] = []
@@ -2953,9 +2998,9 @@ def func(
                         if p.get("it_in")
                     ]
                     + [
-                        f'{p["irt_in"]}/raw'
+                        f'{p["irt_in"]}/{p["transport"].local_republish}'
                         for p in out_pipes
-                        if p.get("irt_in")
+                        if p.get("irt_in") and p["transport"].local_republish
                     ]
                 )
                 blocks.append(
@@ -3152,12 +3197,15 @@ def func(
                     raise ValueError(f"Unsupported transport type '{tspec.type}'")
             blocks.append(PluginBlock("it", items2))
 
-        # Merge reverse-transport config for (a) local reconstruction and (b) inbound remote topics (if requested).
+        # Merge reverse-transport config for (a) the sender's own preview of what
+        # it encoded and (b) the decode of what arrived. Both run on *this* peer;
+        # what differs is which copy they decode and which transport the session
+        # asked each of them to publish in.
         irt_all: List[Tuple[str, str, str]] = []
         for t, tspec in irt_items_local:
             assert tspec is not None
-            irt_all.append((t, tspec.type, "raw"))
-        irt_all.extend((topic, ttype, "raw") for topic, ttype in irt_items_remote)
+            irt_all.append((t, tspec.type, str(tspec.local_republish)))
+        irt_all.extend((topic, tspec.type, str(tspec.remote_republish)) for topic, tspec in irt_items_remote)
         _assert_max("irt", irt_all, 4)
         if irt_all:
             items2 = [("irt", True)]

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev38
+Version: 2.5.dev40
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom_dev.egg-info/SOURCES.txt

@@ -337,6 +337,8 @@ tests/unit/test_ota_unwrapper.py
 tests/unit/test_ota_wrapper.py
 tests/unit/test_ota_xml.py
 tests/unit/test_plots.py
+tests/unit/test_qos_fallback_logging.py
+tests/unit/test_relay_optional_parameters.py
 tests/unit/test_session_pipeline.py
 tests/unit/test_stage_latency.py
 tests/unit/test_status_eval.py

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/src/rosotacom_dev.egg-info/scm_file_list.json

@@ -332,6 +332,8 @@
     "tests/unit/test_ota_wrapper.py",
     "tests/unit/test_ota_xml.py",
     "tests/unit/test_plots.py",
+    "tests/unit/test_qos_fallback_logging.py",
+    "tests/unit/test_relay_optional_parameters.py",
     "tests/unit/test_session_pipeline.py",
     "tests/unit/test_stage_latency.py",
     "tests/unit/test_status_eval.py",

rosotacom_dev-2.5.dev40/src/rosotacom_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.4",
+  "distance": 40,
+  "node": "g679b8af8945b83eea3c582a4e0db6916592635bc",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-17"
+}

{rosotacom_dev-2.5.dev38 → rosotacom_dev-2.5.dev40}/tests/unit/test_catmux_pane_logging.py

@@ -111,3 +111,77 @@ def test_the_hook_is_installed_once_even_if_sourced_twice(pane_env: tuple[Path,
 
     (line,) = [ln for ln in result.stdout.splitlines() if ln.startswith("PC=")]
     assert line.count("__rosotacom_note_exit") == 1
+
+
+# What the recorder cannot know, and why the session template has to care.
+#
+# The hook runs from PROMPT_COMMAND, so it sees every line a pane shell runs --
+# including the lines that only assemble an argument list before the node
+# starts. A line of the form `[[ cond ]] && args+=(...)` exits 1 whenever the
+# condition is false, which is the normal case for every option a session leaves
+# unset, so each one recorded itself as a dead pane. A peer then reported four
+# exited panes at every start while nothing was wrong.
+
+_UNSET_OPTION = '[[ "None" != "None" ]]'
+_SET_OPTION = '[[ "22" != "None" ]]'
+
+
+def _failure_log(catmux_dir: Path) -> Path:
+    return catmux_dir.parent / "pane_failures.log"
+
+
+def test_the_short_circuit_form_records_a_false_failure(pane_env: tuple[Path, dict[str, str]]) -> None:
+    """The shape that was in the template: correct behaviour, status 1."""
+    catmux_dir, env = pane_env
+
+    _run(f'args=(); {_UNSET_OPTION} && args+=(-p "bit_rate:=None")', env)
+
+    assert _failure_log(catmux_dir).is_file()
+    assert "exit=1" in _failure_log(catmux_dir).read_text(encoding="utf-8")
+
+
+def test_the_if_form_leaves_an_unset_option_silent(pane_env: tuple[Path, dict[str, str]]) -> None:
+    """The shape it was replaced with: same behaviour, status 0."""
+    catmux_dir, env = pane_env
+
+    _run(f'args=(); if {_UNSET_OPTION}; then args+=(-p "bit_rate:=None"); fi', env)
+
+    assert not _failure_log(catmux_dir).exists()
+
+
+def test_the_if_form_still_appends_a_set_option(pane_env: tuple[Path, dict[str, str]]) -> None:
+    """Silencing the status must not silence the argument."""
+    catmux_dir, env = pane_env
+
+    result = _run(
+        f'args=(); if {_SET_OPTION}; then args+=(-p "bit_rate:=22"); fi\necho "ARGS=${{args[*]}}"',
+        env,
+    )
+
+    assert "ARGS=-p bit_rate:=22" in result.stdout
+    assert not _failure_log(catmux_dir).exists()
+
+
+def test_no_session_template_line_uses_the_short_circuit_form() -> None:
+    """The template is where this reaches a running session, so it is checked there."""
+    template = (
+        REPO_ROOT
+        / "src"
+        / "rosotacom"
+        / "resources"
+        / "ws"
+        / "session"
+        / "content"
+        / "base"
+        / "session_plugin_base.yaml"
+    )
+    offenders = [
+        line.strip()
+        for line in template.read_text(encoding="utf-8").splitlines()
+        if line.lstrip().startswith("- '[[") and "&&" in line
+    ]
+
+    assert offenders == [], (
+        "these lines exit non-zero when their option is unset and land in "
+        f"pane_failures.log; use `if ...; then ...; fi`: {offenders}"
+    )