fix: Some more convenience methods

Author: tmathern

src/c2pa/c2pa.py

@@ -1660,7 +1660,6 @@ def get_active_manifest(self) -> dict:
         Raises:
             C2paError: If there was an error getting the manifest JSON
             KeyError: If the active_manifest key is missing from the JSON
-            ValueError: If the active manifest ID is not found in the manifests
         """
         # Self-read to get the JSON
         manifest_json_str = self.json()
@@ -1681,10 +1680,42 @@ def get_active_manifest(self) -> dict:
 
         manifests = manifest_data["manifests"]
         if active_manifest_id not in manifests:
-            raise ValueError("Active manifest idnot found in manifests")
+            raise KeyError("Active manifest id not found in manifest store")
 
         return manifests[active_manifest_id]
 
+    def get_manifest_by_label(self, label: str) -> dict:
+        """Get a specific manifest from the manifest store by its label.
+
+        This method retrieves the manifest JSON and extracts the manifest
+        that corresponds to the provided manifest label/ID.
+
+        Args:
+            label: The manifest label/ID to look up in the manifest store
+
+        Returns:
+            A dictionary containing the manifest data for the specified label.
+
+        Raises:
+            C2paError: If there was an error getting the manifest JSON
+            KeyError: If the manifests key is missing from the JSON
+        """
+        # Self-read to get the JSON
+        manifest_json_str = self.json()
+        try:
+            manifest_data = json.loads(manifest_json_str)
+        except json.JSONDecodeError as e:
+            raise C2paError(f"Failed to parse manifest JSON: {str(e)}") from e
+
+        if "manifests" not in manifest_data:
+            raise KeyError("No 'manifests' key found in manifest data")
+
+        manifests = manifest_data["manifests"]
+        if label not in manifests:
+            raise KeyError("Manifest not found in manifest store")
+
+        return manifests[label]
+
     def get_validation_state(self) -> Optional[str]:
         """Get the validation state of the manifest store.
 

tests/test_unit_tests.py

@@ -64,7 +64,7 @@ def test_stream_read(self):
             json_data = reader.json()
             self.assertIn(DEFAULT_TEST_FILE_NAME, json_data)
 
-    def test_stream_read_get_active_manifest(self):
+    def test_get_active_manifest(self):
         with open(self.testPath, "rb") as file:
             reader = Reader("image/jpeg", file)
             active_manifest = reader.get_active_manifest()
@@ -73,6 +73,47 @@ def test_stream_read_get_active_manifest(self):
             expected_label = "contentauth:urn:uuid:c85a2b90-f1a0-4aa4-b17f-f938b475804e"
             self.assertEqual(active_manifest["label"], expected_label)
 
+    def test_get_manifest_by_label(self):
+        with open(self.testPath, "rb") as file:
+            reader = Reader("image/jpeg", file)
+
+            # Test getting manifest by the specific label
+            label = "contentauth:urn:uuid:c85a2b90-f1a0-4aa4-b17f-f938b475804e"
+            manifest = reader.get_manifest_by_label(label)
+
+            # Check that we got the correct manifest
+            self.assertEqual(manifest["label"], label)
+
+            # Verify it's the same as the active manifest (since there's only one)
+            active_manifest = reader.get_active_manifest()
+            self.assertEqual(manifest, active_manifest)
+
+    def test_stream_get_non_active_manifest_by_label(self):
+        video_path = os.path.join(FIXTURES_DIR, "video1.mp4")
+        with open(video_path, "rb") as file:
+            reader = Reader("video/mp4", file)
+
+            non_active_label = "urn:uuid:54281c07-ad34-430e-bea5-112a18facf0b"
+            non_active_manifest = reader.get_manifest_by_label(non_active_label)
+
+            # Check that we got the correct manifest
+            self.assertEqual(non_active_manifest["label"], non_active_label)
+
+            # Verify it's not the active manifest
+            active_manifest = reader.get_active_manifest()
+            self.assertNotEqual(non_active_manifest, active_manifest)
+            self.assertNotEqual(non_active_manifest["label"], active_manifest["label"])
+
+    def test_stream_get_non_active_manifest_by_label_not_found(self):
+        video_path = os.path.join(FIXTURES_DIR, "video1.mp4")
+        with open(video_path, "rb") as file:
+            reader = Reader("video/mp4", file)
+
+            # Try to get a manifest with a label that clearly doesn't exist
+            non_existing_label = "urn:uuid:clearly-not-existing"
+            with self.assertRaises(KeyError):
+                reader.get_manifest_by_label(non_existing_label)
+
     def test_stream_read_get_validation_state(self):
         with open(self.testPath, "rb") as file:
             reader = Reader("image/jpeg", file)