build(pixi): plugins build under conda — dependency normalization + pixi backbone

.gitignore

@@ -10,3 +10,5 @@ __pycache__/
 /conanrunenv-*.sh
 /deactivate_conanbuild.sh
 /deactivate_conanrun.sh
+/.pixi/
+/build/

CMakeLists.txt

@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.22)
 
+# Provider-agnostic dependency target helpers (pj_target_link_*). Defined at the
+# root so they are visible in every add_subdirectory() plugin. Defines functions
+# only — no find_package at include time — so it is safe before the mode branch.
+include(${CMAKE_CURRENT_LIST_DIR}/cmake/PjDependencyTargets.cmake)
+
 # ---------------------------------------------------------------------------
 # Dual-mode: standalone project OR subdirectory of plotjuggler_sdk.
 #

cmake/PjDependencyTargets.cmake

@@ -0,0 +1,194 @@
+# Provider-agnostic dependency linking for the Conan->pixi transition.
+#
+# Several third-party deps expose DIFFERENT CMake target names under Conan
+# (static archives, e.g. Arrow::arrow_static) versus conda-forge (shared libs,
+# e.g. Arrow::arrow_shared) — and a few ship no CMake target at all on
+# conda-forge (lz4-c, asio: pkg-config only). These helpers locate the dep under
+# whichever provider is active and link the correct target, so the SAME plugin
+# CMakeLists builds under both. Under Conan they link the identical *_static
+# targets used before this layer existed (no behavior change).
+#
+# Usage:  pj_target_link_arrow(my_target PRIVATE)   # or PUBLIC / INTERFACE
+include_guard(GLOBAL)
+
+function(pj_target_link_arrow tgt vis)
+  if(NOT TARGET Arrow::arrow_static AND NOT TARGET Arrow::arrow_shared)
+    find_package(Arrow CONFIG REQUIRED)
+  endif()
+  if(TARGET Arrow::arrow_static)
+    target_link_libraries(${tgt} ${vis} Arrow::arrow_static)
+  else()
+    target_link_libraries(${tgt} ${vis} Arrow::arrow_shared)
+  endif()
+endfunction()
+
+function(pj_target_link_parquet tgt vis)
+  if(NOT TARGET Parquet::parquet_static AND NOT TARGET Parquet::parquet_shared)
+    find_package(Parquet CONFIG REQUIRED)
+  endif()
+  if(TARGET Parquet::parquet_static)
+    target_link_libraries(${tgt} ${vis} Parquet::parquet_static)
+  else()
+    target_link_libraries(${tgt} ${vis} Parquet::parquet_shared)
+  endif()
+endfunction()
+
+function(pj_target_link_zstd tgt vis)
+  if(NOT TARGET zstd::libzstd_static AND NOT TARGET zstd::libzstd AND NOT TARGET zstd::libzstd_shared)
+    find_package(zstd CONFIG REQUIRED)
+  endif()
+  if(TARGET zstd::libzstd_static)
+    target_link_libraries(${tgt} ${vis} zstd::libzstd_static)   # Conan
+  elseif(TARGET zstd::libzstd)
+    target_link_libraries(${tgt} ${vis} zstd::libzstd)          # conda-forge (alias -> shared)
+  else()
+    target_link_libraries(${tgt} ${vis} zstd::libzstd_shared)   # custom/distro zstd (shared only)
+  endif()
+endfunction()
+
+function(pj_target_link_lz4 tgt vis)
+  # Conan ships an lz4 CMake config (LZ4::lz4_static); conda-forge lz4-c ships none.
+  # Find it here (QUIET, not REQUIRED) so plugins don't need their own find_package.
+  if(NOT TARGET LZ4::lz4_static AND NOT TARGET lz4::lz4)
+    find_package(lz4 QUIET CONFIG)
+  endif()
+  if(TARGET LZ4::lz4_static)
+    target_link_libraries(${tgt} ${vis} LZ4::lz4_static)        # Conan
+    return()
+  endif()
+  if(TARGET lz4::lz4)
+    target_link_libraries(${tgt} ${vis} lz4::lz4)
+    return()
+  endif()
+  # conda-forge lz4-c ships no CMake config — consume via pkg-config. Guard the
+  # imported-target creation so repeated calls (e.g. mcap links lz4 thrice) and
+  # calls from multiple subdirectories don't re-create PkgConfig::PJ_LZ4.
+  if(NOT TARGET PkgConfig::PJ_LZ4)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(PJ_LZ4 REQUIRED IMPORTED_TARGET liblz4)
+  endif()
+  target_link_libraries(${tgt} ${vis} PkgConfig::PJ_LZ4)
+endfunction()
+
+function(pj_target_link_asio tgt vis)
+  # Conan ships an asio CMake config (asio::asio); conda-forge asio is header-only
+  # with none. Find it here (QUIET) so plugins don't need their own find_package.
+  if(NOT TARGET asio::asio)
+    find_package(asio QUIET CONFIG)
+  endif()
+  if(TARGET asio::asio)
+    target_link_libraries(${tgt} ${vis} asio::asio)             # Conan
+    return()
+  endif()
+  # conda-forge asio is header-only with no CMake target — pkg-config supplies the
+  # include dir. Guard the imported-target creation against repeated/cross-subdir calls.
+  if(NOT TARGET PkgConfig::PJ_ASIO)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(PJ_ASIO REQUIRED IMPORTED_TARGET asio)
+  endif()
+  target_link_libraries(${tgt} ${vis} PkgConfig::PJ_ASIO)
+endfunction()
+
+function(pj_target_link_paho_mqtt tgt vis)
+  if(NOT TARGET PahoMqttCpp::paho-mqttpp3-static AND NOT TARGET PahoMqttCpp::paho-mqttpp3)
+    find_package(PahoMqttCpp CONFIG REQUIRED)
+  endif()
+  if(TARGET PahoMqttCpp::paho-mqttpp3-static)
+    target_link_libraries(${tgt} ${vis} PahoMqttCpp::paho-mqttpp3-static)  # Conan
+  else()
+    target_link_libraries(${tgt} ${vis} PahoMqttCpp::paho-mqttpp3)         # conda-forge
+  endif()
+endfunction()
+
+function(pj_target_link_lua tgt vis)
+  if(NOT TARGET lua::lua)
+    find_package(lua QUIET CONFIG)   # Conan provides lua::lua
+  endif()
+  if(TARGET lua::lua)
+    target_link_libraries(${tgt} ${vis} lua::lua)             # Conan
+    return()
+  endif()
+  # conda-forge lua ships only the builtin FindLua module (LUA_LIBRARIES /
+  # LUA_INCLUDE_DIR) with no namespaced target — wrap it in an imported target.
+  if(NOT TARGET pj_lua)
+    find_package(Lua REQUIRED)
+    add_library(pj_lua INTERFACE IMPORTED GLOBAL)
+    set_target_properties(pj_lua PROPERTIES
+      INTERFACE_LINK_LIBRARIES "${LUA_LIBRARIES}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LUA_INCLUDE_DIR}")
+  endif()
+  target_link_libraries(${tgt} ${vis} pj_lua)
+endfunction()
+
+# Link FFmpeg libav* components by name, e.g.
+#   pj_target_link_ffmpeg(my_target PRIVATE avformat avutil)
+# Conan ships an ffmpeg CMake config (ffmpeg::avformat, ffmpeg::avcodec, ...);
+# conda-forge ffmpeg ships pkg-config (.pc) ONLY, no CMake config. The helper
+# links the Conan targets when present, else builds IMPORTED targets from the
+# libav<component> pkg-config modules. GLOBAL + a per-component TARGET guard make
+# this safe when several subdirectories link the same component (e.g. data_load_mp4
+# and common/pj_video_demux both link avformat/avutil in one build).
+function(pj_target_link_ffmpeg tgt vis)
+  if(NOT TARGET ffmpeg::avutil)
+    find_package(ffmpeg QUIET CONFIG)
+  endif()
+  if(TARGET ffmpeg::avutil)
+    foreach(_c ${ARGN})
+      target_link_libraries(${tgt} ${vis} ffmpeg::${_c})            # Conan
+    endforeach()
+    return()
+  endif()
+  find_package(PkgConfig REQUIRED)
+  foreach(_c ${ARGN})
+    if(NOT TARGET PkgConfig::PJ_FF_${_c})
+      pkg_check_modules(PJ_FF_${_c} REQUIRED IMPORTED_TARGET GLOBAL lib${_c})
+    endif()
+    target_link_libraries(${tgt} ${vis} PkgConfig::PJ_FF_${_c})     # conda-forge
+  endforeach()
+endfunction()
+
+# Availability probe for the graceful-skip in common/pj_video_demux (builds that
+# exercise only non-ffmpeg plugins have no ffmpeg dep at all). Detects ffmpeg under
+# BOTH providers — Conan's CMake config OR conda-forge's pkg-config — so the skip
+# fires only when ffmpeg is genuinely absent, not merely missing a CMake config.
+function(pj_ffmpeg_available out)
+  if(TARGET ffmpeg::avutil)
+    set(${out} TRUE PARENT_SCOPE)
+    return()
+  endif()
+  find_package(ffmpeg QUIET CONFIG)
+  if(TARGET ffmpeg::avutil)
+    set(${out} TRUE PARENT_SCOPE)
+    return()
+  endif()
+  # pkg-config fallback (conda-forge ffmpeg has no CMake config). Gated on an active
+  # conda environment so the Conan aggregate build — which has NO ffmpeg dep and must
+  # SKIP pj_video_demux — never silently picks up a SYSTEM ffmpeg from the host's
+  # pkg-config. Under Conan, ffmpeg arrives only as a CMake config (handled above).
+  if(DEFINED ENV{CONDA_PREFIX})
+    find_package(PkgConfig QUIET)
+    if(PkgConfig_FOUND)
+      pkg_check_modules(PJ_FF_PROBE QUIET libavutil)
+      if(PJ_FF_PROBE_FOUND)
+        set(${out} TRUE PARENT_SCOPE)
+        return()
+      endif()
+    endif()
+  endif()
+  set(${out} FALSE PARENT_SCOPE)
+endfunction()
+
+# Availability probe for the graceful-skip in common/arrow_helpers (some build
+# configs, e.g. the ROS2 proxy leg, have no Arrow dep at all).
+function(pj_arrow_available out)
+  if(TARGET Arrow::arrow_static OR TARGET Arrow::arrow_shared)
+    set(${out} TRUE PARENT_SCOPE)
+    return()
+  endif()
+  find_package(Arrow QUIET CONFIG)
+  if(TARGET Arrow::arrow_static OR TARGET Arrow::arrow_shared)
+    set(${out} TRUE PARENT_SCOPE)
+  else()
+    set(${out} FALSE PARENT_SCOPE)
+  endif()
+endfunction()

common/arrow_helpers/CMakeLists.txt

@@ -9,12 +9,10 @@
 # find_package(Arrow REQUIRED), so a real consumer never silently runs
 # without the target — it errors at the consumer's own find_package.
 
-if(NOT TARGET Arrow::arrow_static)
-  find_package(Arrow QUIET CONFIG)
-  if(NOT TARGET Arrow::arrow_static)
-    message(STATUS "pj_arrow_helpers: Arrow not found, skipping shared helper library")
-    return()
-  endif()
+pj_arrow_available(_pj_have_arrow)
+if(NOT _pj_have_arrow)
+  message(STATUS "pj_arrow_helpers: Arrow not found, skipping shared helper library")
+  return()
 endif()
 
 add_library(pj_arrow_helpers STATIC arrow_helpers.cpp)
@@ -31,7 +29,5 @@ target_include_directories(pj_arrow_helpers PUBLIC
 )
 
 # Arrow types appear in the public API; plugin_sdk supplies PJ::sdk::ValueRef.
-target_link_libraries(pj_arrow_helpers PUBLIC
-  plotjuggler_sdk::plugin_sdk
-  Arrow::arrow_static
-)
+target_link_libraries(pj_arrow_helpers PUBLIC plotjuggler_sdk::plugin_sdk)
+pj_target_link_arrow(pj_arrow_helpers PUBLIC)

common/pj_video_demux/CMakeLists.txt

@@ -9,12 +9,10 @@
 # does its own find_package(ffmpeg REQUIRED), so it never silently runs without
 # the target.
 
-if(NOT TARGET ffmpeg::avformat)
-  find_package(ffmpeg QUIET CONFIG)
-  if(NOT TARGET ffmpeg::avformat)
-    message(STATUS "pj_video_demux: ffmpeg not found, skipping shared helper library")
-    return()
-  endif()
+pj_ffmpeg_available(_pj_have_ffmpeg)
+if(NOT _pj_have_ffmpeg)
+  message(STATUS "pj_video_demux: ffmpeg not found, skipping shared helper library")
+  return()
 endif()
 
 add_library(pj_video_demux STATIC video_demux.cpp)
@@ -31,12 +29,8 @@ target_include_directories(pj_video_demux PUBLIC
 )
 
 # PJ::Span / PJ::Expected come from plugin_sdk; libav* used only for indexing.
-target_link_libraries(pj_video_demux PUBLIC
-  plotjuggler_sdk::plugin_sdk
-  ffmpeg::avformat
-  ffmpeg::avcodec
-  ffmpeg::avutil
-)
+target_link_libraries(pj_video_demux PUBLIC plotjuggler_sdk::plugin_sdk)
+pj_target_link_ffmpeg(pj_video_demux PUBLIC avformat avcodec avutil)
 
 # --- Unit tests: pure byte-rewrite cases + committed h264/hevc/av1 fixtures
 #     (+ an env-gated external e2e via PJ_TEST_VIDEO) ---

data_load_lerobot/CMakeLists.txt

@@ -1,10 +1,4 @@
 find_package(nlohmann_json REQUIRED)
-if(NOT TARGET Arrow::arrow_static)
-  find_package(Arrow REQUIRED)
-endif()
-if(NOT TARGET Parquet::parquet_static)
-  find_package(Parquet REQUIRED)
-endif()
 
 include(${CMAKE_CURRENT_LIST_DIR}/../cmake/EmbedUi.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/../cmake/EmbedManifest.cmake)
@@ -21,10 +15,11 @@ target_compile_features(lerobot_source_plugin PRIVATE cxx_std_20)
 target_compile_options(lerobot_source_plugin PRIVATE ${PJ_WARNING_FLAGS})
 target_link_libraries(lerobot_source_plugin PRIVATE
   plotjuggler_sdk::plugin_sdk nlohmann_json::nlohmann_json
-  Arrow::arrow_static Parquet::parquet_static
   pj_arrow_helpers
   pj_video_demux  # lazy per-frame VideoFrame emission (pulls ffmpeg transitively)
 )
+pj_target_link_arrow(lerobot_source_plugin PRIVATE)
+pj_target_link_parquet(lerobot_source_plugin PRIVATE)
 pj_embed_ui(lerobot_source_plugin
   UI_FILE  ${CMAKE_CURRENT_SOURCE_DIR}/dialog_lerobot.ui
   HEADER   ${CMAKE_CURRENT_BINARY_DIR}/generated/dialog_lerobot_ui.hpp
@@ -53,8 +48,10 @@ target_compile_options(lerobot_dataset_model_test PRIVATE ${PJ_WARNING_FLAGS})
 target_include_directories(lerobot_dataset_model_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(lerobot_dataset_model_test PRIVATE
   plotjuggler_sdk::plugin_sdk plotjuggler_sdk::plugin_host nlohmann_json::nlohmann_json
-  Arrow::arrow_static Parquet::parquet_static GTest::gtest_main
+  GTest::gtest_main
 )
+pj_target_link_arrow(lerobot_dataset_model_test PRIVATE)
+pj_target_link_parquet(lerobot_dataset_model_test PRIVATE)
 add_test(NAME lerobot_dataset_model_test COMMAND lerobot_dataset_model_test)
 
 # v3.0 fixture test — exercises the Arrow-backed meta/episodes reader against
@@ -65,8 +62,10 @@ target_compile_options(lerobot_dataset_model_v3_test PRIVATE ${PJ_WARNING_FLAGS}
 target_include_directories(lerobot_dataset_model_v3_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(lerobot_dataset_model_v3_test PRIVATE
   plotjuggler_sdk::plugin_sdk plotjuggler_sdk::plugin_host nlohmann_json::nlohmann_json
-  Arrow::arrow_static Parquet::parquet_static GTest::gtest_main
+  GTest::gtest_main
 )
+pj_target_link_arrow(lerobot_dataset_model_v3_test PRIVATE)
+pj_target_link_parquet(lerobot_dataset_model_v3_test PRIVATE)
 add_test(NAME lerobot_dataset_model_v3_test COMMAND lerobot_dataset_model_v3_test)
 
 add_executable(lerobot_flatten_plan_test tests/flatten_plan_test.cpp flatten_plan.cpp)
@@ -102,8 +101,10 @@ target_compile_options(lerobot_dialog_fanout_test PRIVATE ${PJ_WARNING_FLAGS})
 target_include_directories(lerobot_dialog_fanout_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(lerobot_dialog_fanout_test PRIVATE
   plotjuggler_sdk::plugin_sdk plotjuggler_sdk::plugin_host nlohmann_json::nlohmann_json
-  Arrow::arrow_static Parquet::parquet_static GTest::gtest_main
+  GTest::gtest_main
 )
+pj_target_link_arrow(lerobot_dialog_fanout_test PRIVATE)
+pj_target_link_parquet(lerobot_dialog_fanout_test PRIVATE)
 # Pull in the generated headers (dialog_lerobot_ui.hpp, lerobot_manifest.hpp)
 # that lerobot_dialog.hpp transitively includes.
 target_include_directories(lerobot_dialog_fanout_test PRIVATE

data_load_mcap/CMakeLists.txt

@@ -1,6 +1,4 @@
 find_package(nlohmann_json REQUIRED)
-find_package(lz4 REQUIRED)
-find_package(zstd REQUIRED)
 
 include(${CMAKE_CURRENT_LIST_DIR}/../cmake/EmbedUi.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/../cmake/EmbedManifest.cmake)
@@ -13,8 +11,10 @@ target_compile_features(mcap_source_plugin PRIVATE cxx_std_20)
 target_compile_options(mcap_source_plugin PRIVATE ${PJ_WARNING_FLAGS})
 target_include_directories(mcap_source_plugin SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/contrib)
 target_link_libraries(mcap_source_plugin PRIVATE
-  plotjuggler_sdk::plugin_sdk nlohmann_json::nlohmann_json LZ4::lz4_static zstd::libzstd_static
+  plotjuggler_sdk::plugin_sdk nlohmann_json::nlohmann_json
 )
+pj_target_link_lz4(mcap_source_plugin PRIVATE)
+pj_target_link_zstd(mcap_source_plugin PRIVATE)
 
 pj_embed_ui(mcap_source_plugin
   UI_FILE  ${CMAKE_CURRENT_SOURCE_DIR}/dialog_mcap.ui
@@ -40,7 +40,9 @@ target_compile_features(mcap_helpers_test PRIVATE cxx_std_20)
 target_compile_options(mcap_helpers_test PRIVATE ${PJ_WARNING_FLAGS})
 target_include_directories(mcap_helpers_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(mcap_helpers_test SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/contrib)
-target_link_libraries(mcap_helpers_test PRIVATE LZ4::lz4_static zstd::libzstd_static GTest::gtest_main)
+target_link_libraries(mcap_helpers_test PRIVATE GTest::gtest_main)
+pj_target_link_lz4(mcap_helpers_test PRIVATE)
+pj_target_link_zstd(mcap_helpers_test PRIVATE)
 add_test(NAME mcap_helpers_test COMMAND mcap_helpers_test)
 
 # --- Unit test for the MessageByteStore (hot/cold lazy byte layer) ---
@@ -51,6 +53,8 @@ target_compile_options(message_byte_store_test PRIVATE ${PJ_WARNING_FLAGS})
 target_include_directories(message_byte_store_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_include_directories(message_byte_store_test SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/contrib)
 target_link_libraries(message_byte_store_test PRIVATE
-  LZ4::lz4_static zstd::libzstd_static GTest::gtest_main Threads::Threads
+  GTest::gtest_main Threads::Threads
 )
+pj_target_link_lz4(message_byte_store_test PRIVATE)
+pj_target_link_zstd(message_byte_store_test PRIVATE)
 add_test(NAME message_byte_store_test COMMAND message_byte_store_test)

data_load_mp4/CMakeLists.txt

@@ -1,6 +1,7 @@
 find_package(nlohmann_json REQUIRED)
-find_package(ffmpeg REQUIRED)
 find_package(date REQUIRED)
+# ffmpeg linked via pj_target_link_ffmpeg below (conda-forge ffmpeg is pkg-config
+# only, no CMake config); see cmake/PjDependencyTargets.cmake.
 
 include(${CMAKE_CURRENT_LIST_DIR}/../cmake/EmbedManifest.cmake)
 
@@ -10,9 +11,9 @@ target_compile_features(mp4_source_plugin PRIVATE cxx_std_20)
 target_compile_options(mp4_source_plugin PRIVATE ${PJ_WARNING_FLAGS})
 target_link_libraries(mp4_source_plugin PRIVATE
   plotjuggler_sdk::plugin_sdk nlohmann_json::nlohmann_json date::date
-  ffmpeg::avformat ffmpeg::avutil
   pj_video_demux
 )
+pj_target_link_ffmpeg(mp4_source_plugin PRIVATE avformat avutil)
 
 pj_embed_manifest(mp4_source_plugin
   HEADER   ${CMAKE_CURRENT_BINARY_DIR}/generated/mp4_manifest.hpp