pw_sensor: Allow missing 'org' in compatible descriptor

When providing a sensor descriptor, most will leverage the org,part
schema. This does not always seem to be the case. There are times where
the org is missing when used in downstream Zephyr. We should allow for
this case and only include the org when provided and not empty.

BUG=b/386143823

Change-Id: Ie3f044b5adbbcbc76ed13716c705561e87adac32

Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/256773
Lint: Lint 🤖 <[email protected]>
Commit-Queue: Yuval Peress <[email protected]>
Reviewed-by: Carlos Chinchilla <[email protected]>
Docs-Not-Needed: Yuval Peress <[email protected]>

pw_sensor/py/pw_sensor/metadata_schema.json

@@ -26,7 +26,6 @@
       },
       "additionalProperties": false,
       "required": [
-        "org",
         "part"
       ]
     },

pw_sensor/py/pw_sensor/resolved_schema.json

@@ -121,7 +121,7 @@
       "type": "object",
       "description": "Set of sensors using their compatible string as a key in the format 'org','part'",
       "patternProperties": {
-        "^[a-zA-Z_][a-zA-Z0-9_\\-]*,[a-zA-Z_][a-zA-Z0-9_\\-]*$": {
+        "^[a-zA-Z0-9_\\-]*,?[a-zA-Z_][a-zA-Z0-9_\\-]*$": {
           "type": "object",
           "description": "A single sensor definition",
           "properties": {
@@ -140,7 +140,6 @@
               },
               "additionalProperties": false,
               "required": [
-                "org",
                 "part"
               ]
             },

pw_sensor/py/pw_sensor/validator.py

@@ -132,13 +132,15 @@ def validate(self, metadata: dict) -> dict:
         # Resolve all trigger entries
         self._resolve_triggers(metadata=metadata, out=result)
 
-        compatible = metadata.pop("compatible")
+        compatible, compatible_str = Validator._get_compatible_string_and_dict(
+            metadata.pop("compatible")
+        )
         supported_buses = metadata.pop("supported-buses")
         channels = metadata.pop("channels")
         attributes = metadata.pop("attributes")
         triggers = metadata.pop("triggers")
 
-        result["sensors"][f"{compatible['org']},{compatible['part']}"] = {
+        result["sensors"][compatible_str] = {
             "compatible": compatible,
             "supported-buses": self._normalize_supported_buses(supported_buses),
             "channels": channels,
@@ -152,10 +154,11 @@ def validate(self, metadata: dict) -> dict:
         try:
             jsonschema.validate(instance=result, schema=_RESOLVED_SCHEMA)
         except jsonschema.exceptions.ValidationError as e:
-            raise RuntimeError(
+            msg = (
                 "ERROR: Malformed output YAML: "
                 f"{yaml.safe_dump(result, indent=2)}"
-            ) from e
+            )
+            raise RuntimeError(msg) from e
 
         return result
 
@@ -185,6 +188,40 @@ def _normalize_supported_buses(buses: list[str]) -> list[str]:
             raise RuntimeError(error)
         return filtered_list
 
+    @staticmethod
+    def _get_compatible_string_and_dict(
+        compatible: dict[str, str],
+    ) -> tuple[dict[str, str], str]:
+        """
+        Normalize compatible info
+
+        This function processes a 'compatible' dictionary with a 'part' key and
+        an optional 'org' key. It returns a new dictionary with the 'org' key
+        removed if it was empty or missing, and a formatted string based on the
+        'org' key's presence and value.
+
+        Args:
+            compatible (dict[str, str]): A dictionary with a 'part' key and an
+            optional 'org' key.
+
+        Returns:
+            Tuple[dict[str, str], str]: A tuple containing:
+            - A new dictionary with the 'org' key removed if it was empty or
+              missing.
+            - A formatted string:
+              - "{org},{part}" if 'org' exists and is not empty (after trimming)
+              - "part" otherwise.
+
+        """
+        part = compatible["part"].lower()
+        org = compatible.get("org", "").strip().lower()
+
+        new_compatible = {"part": part}
+        if org:
+            new_compatible["org"] = org
+            return new_compatible, f"{org},{part}"
+        return new_compatible, part
+
     def _resolve_dependencies(self, metadata: dict, out: dict) -> None:
         """
         Given a list of dependencies, ensure that each of them exists and

pw_sensor/py/validator_test.py

@@ -42,7 +42,7 @@ def test_invalid_compatible_type(self) -> None:
                 + "supported-buses:\n- i2c"
             ),
             cause_substrings=[
-                "'org' is a required property",
+                "'part' is a required property",
             ],
         )
 
@@ -73,6 +73,46 @@ def test_invalid_compatible_type(self) -> None:
             cause_substrings=[" is not of type 'object'"],
         )
 
+    def test_partial_compatible_string(self) -> None:
+        """
+        Check that missing 'org' generates correct keys and empty entries are
+        removed.
+        """
+        metadata: dict = {
+            "compatible": {"part": "pigweed"},
+            "supported-buses": ["i2c"],
+        }
+        result = Validator().validate(metadata=metadata)
+        self.assertIn("pigweed", result["sensors"])
+        self.assertDictEqual(
+            {"part": "pigweed"},
+            result["sensors"]["pigweed"]["compatible"],
+        )
+
+        metadata["compatible"]["org"] = " "
+        result = Validator().validate(metadata=metadata)
+        self.assertIn("pigweed", result["sensors"])
+        self.assertDictEqual(
+            {"part": "pigweed"},
+            result["sensors"]["pigweed"]["compatible"],
+        )
+
+    def test_compatible_string_to_lower(self) -> None:
+        """
+        Check that compatible components are converted to lowercase and
+        stripped.
+        """
+        metadata = {
+            "compatible": {"org": "Google", "part": "Pigweed"},
+            "supported-buses": ["i2c"],
+        }
+        result = Validator().validate(metadata=metadata)
+        self.assertIn("google,pigweed", result["sensors"])
+        self.assertDictEqual(
+            {"org": "google", "part": "pigweed"},
+            result["sensors"]["google,pigweed"]["compatible"],
+        )
+
     def test_invalid_supported_buses(self) -> None:
         """
         Check that invalid or missing supported-buses cause an error