Fix version check (#75)

# Pull Request

### What change is being made

Fix the version check in C++ and Python

### Why this change is being made

Fix.

### Tested

Tests are passing.

GitOrigin-RevId: 3ee94d15ab67a130e45d724fea1a770c19858187

Author: awoll-bdai

control/context.cpp

@@ -65,10 +65,7 @@ bool OnnxContext::createContext(OnnxRuntime& onnx_model, bool strict) {
     return false;
   }
 
-  // TODO: enable strict mode to ensure version compatibility.
-  if (!metadata::checkExployVersion(onnx_model.getCustomMetadata("exploy_version"),
-                                    /*strict*/ false))
-    return false;
+  if (!metadata::checkExployVersion(onnx_model.getCustomMetadata("exploy_version"))) return false;
 
   std::optional<int> maybe_update_rate = parseUpdateRate(onnx_model);
   if (!maybe_update_rate.has_value()) return false;
@@ -123,7 +120,6 @@ bool OnnxContext::createContext(OnnxRuntime& onnx_model, bool strict) {
     });
   }
 
-  // TODO: simplify
   for (auto& matcher : matchers_) {
     auto inputs = matcher->createInputs();
     inputs_.insert(inputs_.end(), std::make_move_iterator(inputs.begin()),

control/metadata.hpp

@@ -251,89 +251,79 @@ inline void from_json(const json& j, JointMetadata& jm) {
 }
 
 /**
- * @brief Parsed semantic version (MAJOR.MINOR.PATCH).
+ * @brief Parsed version (MAJOR.MINOR).
  */
 struct Version {
   int major{0};
   int minor{0};
-  int patch{0};
 
-  std::string toString() const { return fmt::format("{}.{}.{}", major, minor, patch); }
+  std::string toString() const { return fmt::format("{}.{}", major, minor); }
 
   bool operator<=(const Version& other) const {
     if (major != other.major) return major < other.major;
-    if (minor != other.minor) return minor < other.minor;
-    return patch <= other.patch;
+    return minor <= other.minor;
   }
 };
 
-constexpr Version kMinSupportedExployVersion{0, 1, 0};
-constexpr Version kMaxSupportedExployVersion{0, 1, 0};
+constexpr Version kMinSupportedExployVersion{0, 0};
 
 /**
- * @brief Parse a "MAJOR.MINOR.PATCH" version string.
+ * @brief Parse a version string into MAJOR.MINOR.
  *
- * @param s Version string to parse.
- * @return Parsed Version, or std::nullopt if the string is not a valid semver.
+ * Only the leading MAJOR.MINOR digits are extracted; any trailing content
+ * (e.g. ".PATCH", ".postN", ".devN", "+local") is ignored.
+ *
+ * @param s Version string to parse (e.g. "1.2.3", "0.0.post1.dev96+gabcdef").
+ * @return Parsed Version, or std::nullopt if the string does not start with MAJOR.MINOR.
  */
 inline std::optional<Version> parseVersion(const std::string& s) {
-  static const std::regex kVersionRegex(R"(^(\d+)\.(\d+)\.(\d+)$)");
+  static const std::regex kVersionRegex(R"(^(\d+)\.(\d+))");
   std::smatch match;
-  if (!std::regex_match(s, match, kVersionRegex)) return std::nullopt;
-  return Version{std::stoi(match[1]), std::stoi(match[2]), std::stoi(match[3])};
+  if (!std::regex_search(s, match, kVersionRegex)) return std::nullopt;
+  return Version{std::stoi(match[1]), std::stoi(match[2])};
 }
 
 /**
- * @brief Check that the ONNX model's exploy_version metadata is present and within the supported
- * range [kMinSupportedExployVersion, kMaxSupportedExployVersion]. Logs an error if not.
+ * @brief Check that the ONNX model's exploy_version metadata is present and at least
+ * @p min_version. Logs an error if not.
  *
  * @param maybe_version_str The value of the "exploy_version" metadata key, or std::nullopt if
  * absent.
- * @param strict If true, treat mismatch as a failure. If false, only log a warning and return true.
- * @return true if the version is present and within the supported range, false otherwise.
+ * @param min_version Minimum accepted version. Defaults to kMinSupportedExployVersion.
+ * @return true if the version is present and >= @p min_version, false otherwise.
  */
 inline bool checkExployVersion(const std::optional<std::string>& maybe_version_str,
-                               bool strict = true) {
-  const auto log = [&](const std::string& msg) {
-    if (strict) {
-      LOG_STREAM(ERROR, msg);
-    } else {
-      LOG_STREAM(WARN, msg);
-    }
-  };
-
+                               const Version& min_version = kMinSupportedExployVersion) {
   if (!maybe_version_str.has_value()) {
-    log("ONNX model does not contain 'exploy_version' metadata. "
-        "The ONNX file might not be compatible with this controller.");
-    return !strict;
+    LOG_STREAM(ERROR,
+               "ONNX model does not contain 'exploy_version' metadata. "
+               "The ONNX file might not be compatible with this controller.");
+    return false;
   }
 
   std::string version_str;
   try {
     version_str = json::parse(maybe_version_str.value()).get<std::string>();
   } catch (const json::exception&) {
-    log(
-        fmt::format("Failed to JSON parse exploy_version: '{}'. "
-                    "The ONNX file might not be compatible with this controller.",
-                    maybe_version_str.value()));
-    return !strict;
+    LOG_STREAM(ERROR, fmt::format("Failed to JSON parse exploy_version: '{}'. "
+                                  "The ONNX file might not be compatible with this controller.",
+                                  maybe_version_str.value()));
+    return false;
   }
 
   auto maybe_version = parseVersion(version_str);
   if (!maybe_version.has_value()) {
-    log(
-        fmt::format("Failed to parse exploy_version: '{}'. "
-                    "The ONNX file might not be compatible with this controller.",
-                    version_str));
-    return !strict;
+    LOG_STREAM(ERROR, fmt::format("Failed to parse exploy_version: '{}'. "
+                                  "The ONNX file might not be compatible with this controller.",
+                                  version_str));
+    return false;
   }
 
   const auto& v = maybe_version.value();
-  const bool in_range = kMinSupportedExployVersion <= v && v <= kMaxSupportedExployVersion;
-  if (!in_range) {
-    log(fmt::format("exploy_version '{}' is outside the supported range [{}, {}].", version_str,
-                    kMinSupportedExployVersion.toString(), kMaxSupportedExployVersion.toString()));
-    return !strict;
+  if (!(min_version <= v)) {
+    LOG_STREAM(ERROR, fmt::format("exploy_version '{}' is below the minimum supported version {}.",
+                                  version_str, min_version.toString()));
+    return false;
   }
   return true;
 }

control/test/metadata_test.cpp

@@ -9,31 +9,26 @@ namespace exploy::control::metadata {
 // ========== Version::toString ==========
 
 TEST(VersionTest, ToString) {
-  EXPECT_EQ((Version{1, 2, 3}.toString()), "1.2.3");
-  EXPECT_EQ((Version{0, 0, 0}.toString()), "0.0.0");
-  EXPECT_EQ((Version{10, 20, 30}.toString()), "10.20.30");
+  EXPECT_EQ((Version{1, 2}.toString()), "1.2");
+  EXPECT_EQ((Version{0, 0}.toString()), "0.0");
+  EXPECT_EQ((Version{10, 20}.toString()), "10.20");
 }
 
 // ========== Version::operator<= ==========
 
 TEST(VersionTest, ComparisonEqualVersions) {
-  EXPECT_TRUE((Version{1, 2, 3} <= Version{1, 2, 3}));
-  EXPECT_TRUE((Version{0, 0, 0} <= Version{0, 0, 0}));
+  EXPECT_TRUE((Version{1, 2} <= Version{1, 2}));
+  EXPECT_TRUE((Version{0, 0} <= Version{0, 0}));
 }
 
 TEST(VersionTest, ComparisonMajorDiffers) {
-  EXPECT_TRUE((Version{0, 9, 9} <= Version{1, 0, 0}));
-  EXPECT_FALSE((Version{2, 0, 0} <= Version{1, 9, 9}));
+  EXPECT_TRUE((Version{0, 9} <= Version{1, 0}));
+  EXPECT_FALSE((Version{2, 0} <= Version{1, 9}));
 }
 
 TEST(VersionTest, ComparisonMinorDiffers) {
-  EXPECT_TRUE((Version{1, 1, 9} <= Version{1, 2, 0}));
-  EXPECT_FALSE((Version{1, 3, 0} <= Version{1, 2, 9}));
-}
-
-TEST(VersionTest, ComparisonPatchDiffers) {
-  EXPECT_TRUE((Version{1, 2, 2} <= Version{1, 2, 3}));
-  EXPECT_FALSE((Version{1, 2, 4} <= Version{1, 2, 3}));
+  EXPECT_TRUE((Version{1, 1} <= Version{1, 2}));
+  EXPECT_FALSE((Version{1, 3} <= Version{1, 2}));
 }
 
 // ========== parseVersion ==========
@@ -43,43 +38,57 @@ TEST(ParseVersionTest, ValidVersion) {
   ASSERT_TRUE(v.has_value());
   EXPECT_EQ(v->major, 1);
   EXPECT_EQ(v->minor, 2);
-  EXPECT_EQ(v->patch, 3);
 }
 
 TEST(ParseVersionTest, ZeroVersion) {
   auto v = parseVersion("0.0.0");
   ASSERT_TRUE(v.has_value());
   EXPECT_EQ(v->major, 0);
   EXPECT_EQ(v->minor, 0);
-  EXPECT_EQ(v->patch, 0);
 }
 
 TEST(ParseVersionTest, LargeNumbers) {
   auto v = parseVersion("10.20.30");
   ASSERT_TRUE(v.has_value());
   EXPECT_EQ(v->major, 10);
   EXPECT_EQ(v->minor, 20);
-  EXPECT_EQ(v->patch, 30);
 }
 
 TEST(ParseVersionTest, EmptyString) {
   EXPECT_FALSE(parseVersion("").has_value());
 }
 
 TEST(ParseVersionTest, MissingPatch) {
-  EXPECT_FALSE(parseVersion("1.2").has_value());
+  auto v = parseVersion("1.2");
+  ASSERT_TRUE(v.has_value());
+  EXPECT_EQ(v->major, 1);
+  EXPECT_EQ(v->minor, 2);
 }
 
 TEST(ParseVersionTest, ExtraComponent) {
-  EXPECT_FALSE(parseVersion("1.2.3.4").has_value());
+  auto v = parseVersion("1.2.3.4");
+  ASSERT_TRUE(v.has_value());
+  EXPECT_EQ(v->major, 1);
+  EXPECT_EQ(v->minor, 2);
+}
+
+TEST(ParseVersionTest, PythonDevVersion) {
+  auto v = parseVersion("0.0.post1.dev96+g1cdbae3db");
+  ASSERT_TRUE(v.has_value());
+  EXPECT_EQ(v->major, 0);
+  EXPECT_EQ(v->minor, 0);
 }
 
 TEST(ParseVersionTest, NonNumericComponents) {
   EXPECT_FALSE(parseVersion("a.b.c").has_value());
 }
 
 TEST(ParseVersionTest, NegativeComponent) {
-  EXPECT_FALSE(parseVersion("1.2.-3").has_value());
+  // "1.2.-3" — trailing content after MAJOR.MINOR is ignored
+  auto v = parseVersion("1.2.-3");
+  ASSERT_TRUE(v.has_value());
+  EXPECT_EQ(v->major, 1);
+  EXPECT_EQ(v->minor, 2);
 }
 
 TEST(ParseVersionTest, WithVPrefix) {
@@ -107,18 +116,18 @@ TEST(CheckExployVersionTest, InvalidSemver) {
 }
 
 TEST(CheckExployVersionTest, VersionBelowMinimum) {
-  // kMinSupportedExployVersion is 0.1.0, so 0.0.9 is below the minimum
-  EXPECT_FALSE(checkExployVersion("\"0.0.9\""));
+  constexpr Version min{1, 2};
+  EXPECT_FALSE(checkExployVersion("\"1.1.9\"", min));
 }
 
-TEST(CheckExployVersionTest, VersionAboveMaximum) {
-  // kMaxSupportedExployVersion is 0.1.0, so 0.2.0 is above the maximum
-  EXPECT_FALSE(checkExployVersion("\"0.2.0\""));
+TEST(CheckExployVersionTest, SupportedVersion) {
+  constexpr Version min{1, 2};
+  EXPECT_TRUE(checkExployVersion("\"1.2.0\"", min));
 }
 
-TEST(CheckExployVersionTest, SupportedVersion) {
-  // kMinSupportedExployVersion == kMaxSupportedExployVersion == 0.1.0
-  EXPECT_TRUE(checkExployVersion("\"0.1.0\""));
+TEST(CheckExployVersionTest, VersionAboveMinimum) {
+  constexpr Version min{1, 2};
+  EXPECT_TRUE(checkExployVersion("\"1.3.0\"", min));
 }
 
 }  // namespace exploy::control::metadata

python/exploy/exporter/core/utils/paths.py

@@ -18,15 +18,15 @@
 
 
 def get_exploy_version() -> str:
-    """Get the installed exploy-exporter-core package version.
+    """Get the installed exploy package version.
 
     Returns:
-        Version string, or "unknown" if the package metadata is not available.
+        Version string, or "0.0.0" if the package metadata is not available.
     """
     try:
-        return importlib.metadata.version("exploy-exporter-core")
+        return importlib.metadata.version("exploy")
     except importlib.metadata.PackageNotFoundError:
-        return "unknown"
+        return "0.0.0"
 
 
 def _ensure_onnx_extension(filename: str) -> pathlib.Path: