fix: New bindings

Author: tmathern

src/c2pa/c2pa.py

@@ -64,11 +64,10 @@
     'c2pa_free_string_array',
     'c2pa_reader_supported_mime_types',
     'c2pa_builder_supported_mime_types',
+    'c2pa_reader_is_embedded',
+    'c2pa_reader_remote_url',
 ]
 
-# TODO Bindings:
-# c2pa_reader_is_embedded
-# c2pa_reader_remote_url
 
 
 def _validate_library_exports(lib):
@@ -369,6 +368,16 @@ def _setup_function(func, argtypes, restype=None):
     [ctypes.POINTER(ctypes.c_size_t)],
     ctypes.POINTER(ctypes.c_char_p)
 )
+_setup_function(
+    _lib.c2pa_reader_is_embedded,
+    [ctypes.POINTER(C2paReader)],
+    ctypes.c_bool
+)
+_setup_function(
+    _lib.c2pa_reader_remote_url,
+    [ctypes.POINTER(C2paReader)],
+    ctypes.c_void_p
+)
 
 # Set up Builder function prototypes
 _setup_function(
@@ -1677,6 +1686,52 @@ def resource_to_stream(self, uri: str, stream: Any) -> int:
 
             return result
 
+    def is_embedded(self) -> bool:
+        """Check if the reader was created from an embedded manifest.
+
+        This method determines whether the C2PA manifest is embedded directly
+        in the asset file or stored remotely.
+
+        Returns:
+            True if the reader was created from an embedded manifest,
+            False if it was created from a remote manifest
+
+        Raises:
+            C2paError: If there was an error checking the embedded status
+        """
+        self._ensure_valid_state()
+
+        result = _lib.c2pa_reader_is_embedded(self._reader)
+
+        # c_bool should return a Python bool directly
+        return bool(result)
+
+    def get_remote_url(self) -> Optional[str]:
+        """Get the remote URL of the manifest if it was obtained remotely.
+
+        This method returns the URL from which the C2PA manifest was fetched
+        if the reader was created from a remote manifest. If the manifest
+        is embedded in the asset, this will return None.
+
+        Returns:
+            The remote URL as a string if the manifest was obtained remotely,
+            None if the manifest is embedded or no remote URL is available
+
+        Raises:
+            C2paError: If there was an error getting the remote URL
+        """
+        self._ensure_valid_state()
+
+        result = _lib.c2pa_reader_remote_url(self._reader)
+
+        if result is None:
+            # No remote URL set (manifest is embedded)
+            return None
+
+        # Convert the C string to Python string
+        url_str = _convert_to_py_string(result)
+        return url_str
+
 
 class Signer:
     """High-level wrapper for C2PA Signer operations."""

tests/test_unit_tests.py

@@ -367,6 +367,82 @@ def test_reader_state_with_invalid_native_pointer(self):
     #         assert active_manifest is not None, "Active manifest should not be null"
     #         assert len(active_manifest) > 0, "Active manifest should not be empty"
 
+    def test_reader_is_embedded(self):
+        """Test the is_embedded method returns correct values for embedded and remote manifests."""
+
+        with open(self.testPath, "rb") as file:
+            reader = Reader("image/jpeg", file)
+            self.assertTrue(reader.is_embedded(),)
+            reader.close()
+
+        # Test remote manifest
+        with open(os.path.join(self.data_dir, "es256_certs.pem"), "rb") as cert_file:
+            certs = cert_file.read()
+        with open(os.path.join(self.data_dir, "es256_private.key"), "rb") as key_file:
+            key = key_file.read()
+
+        # Create signer info and signer
+        signer_info = C2paSignerInfo(
+            alg=b"es256",
+            sign_cert=certs,
+            private_key=key,
+            ta_url=b"http://timestamp.digicert.com"
+        )
+        signer = Signer.from_info(signer_info)
+
+        # Define a simple manifest
+        manifest_definition = {
+            "claim_generator": "python_test",
+            "claim_generator_info": [{
+                "name": "python_test",
+                "version": "0.0.1",
+            }],
+            "claim_version": 1,
+            "format": "image/jpeg",
+            "title": "Python Test Image",
+            "ingredients": [],
+            "assertions": [
+                {
+                    "label": "c2pa.actions",
+                    "data": {
+                        "actions": [
+                            {
+                                "action": "c2pa.opened"
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+
+        # Test remote manifest
+        with open(self.testPath, "rb") as file:
+            builder = Builder(manifest_definition)
+            builder.set_no_embed()
+            with io.BytesIO() as output_buffer:
+                manifest_data = builder.sign(
+                    signer, "image/jpeg", file, output_buffer)
+                output_buffer.seek(0)
+                read_buffer = io.BytesIO(output_buffer.getvalue())
+
+                with Reader("image/jpeg", read_buffer, manifest_data) as reader:
+                    self.assertFalse(reader.is_embedded(), "Remote manifest should return False")
+
+    def test_reader_get_remote_url(self):
+        """Test the get_remote_url method returns correct values for embedded and remote manifests."""
+
+        # Test embedded manifest (should return None)
+        with open(self.testPath, "rb") as file:
+            reader = Reader("image/jpeg", file)
+            self.assertIsNone(reader.get_remote_url(), "Embedded manifest should return None for remote URL")
+            reader.close()
+
+        # Test remote manifest using cloud.jpg fixture which has a remote URL
+        cloud_fixture_path = os.path.join(self.data_dir, "files-for-reading-tests", "cloud.jpg")
+        with Reader("image/jpeg", cloud_fixture_path) as reader:
+            remote_url = reader.get_remote_url()
+            self.assertFalse(reader.is_embedded(), "This should be a remote manifest")
+
 
 class TestBuilderWithSigner(unittest.TestCase):
     def setUp(self):