c2pa-python 0.32.12__tar.gz → 0.32.14__tar.gz

{c2pa_python-0.32.12/src/c2pa_python.egg-info → c2pa_python-0.32.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.32.12
+Version: 0.32.14
 Summary: Python bindings for the C2PA Content Authenticity Initiative (CAI) library
 Author-email: Gavin Peacock <gvnpeacock@adobe.com>, Tania Mathern <mathern@adobe.com>
 Maintainer-email: Gavin Peacock <gpeacock@adobe.com>
@@ -69,6 +69,48 @@ To use the module in Python code, import the module like this:
 import c2pa
 ```
 
+## Building from local c2pa-rs sources
+
+### Using a virtual environment with local builds
+
+The `make` targets honor an active virtualenv. Create a virtual environment `./.venv` and activate it before running them so commands use the project interpreter rather than the global Python interpreter:
+
+```sh
+make create-venv && source .venv/bin/activate
+```
+
+### Build steps
+
+By default the build downloads a prebuilt native library from a [c2pa-rs](https://github.com/contentauth/c2pa-rs) release. To test the Python bindings against a local, unreleased c2pa-rs checkout, you can instead build the native library from source.
+
+Prerequisites:
+
+- A local clone of [c2pa-rs](https://github.com/contentauth/c2pa-rs).
+- The [Rust toolchain](https://rust-lang.org/tools/install/) (`cargo` on your `PATH`).
+
+Point `C2PA_RS_PATH` at your c2pa-rs checkout and run the `build-from-source` target:
+
+```sh
+export C2PA_RS_PATH=/path/to/c2pa-rs
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH
+```
+
+This does a clean build of the `c2pa-c-ffi` crate (with the `file_io` feature, which the Python wrapper requires), stages the resulting library under both `artifacts/` and `src/c2pa/libs/`, and installs the package in editable mode, replacing any prebuilt artifacts from `make download-native-artifacts`. The release profile is used by default; to build the debug profile instead, pass `EXTRA_BUILD_ARGS="--debug"`:
+
+```sh
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH EXTRA_BUILD_ARGS="--debug"
+```
+
+### Note on targets for macOS
+
+On macOS this produces a universal (arm64+x86_64) library by default, which requires both Rust targets:
+
+```sh
+rustup target add aarch64-apple-darwin x86_64-apple-darwin
+```
+
+To build a single-architecture library instead, set `C2PA_LIBS_PLATFORM` to a specific platform (for example `aarch64-apple-darwin`).
+
 ## Examples
 
 See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:

{c2pa_python-0.32.12 → c2pa_python-0.32.14}/README.md

@@ -46,6 +46,48 @@ To use the module in Python code, import the module like this:
 import c2pa
 ```
 
+## Building from local c2pa-rs sources
+
+### Using a virtual environment with local builds
+
+The `make` targets honor an active virtualenv. Create a virtual environment `./.venv` and activate it before running them so commands use the project interpreter rather than the global Python interpreter:
+
+```sh
+make create-venv && source .venv/bin/activate
+```
+
+### Build steps
+
+By default the build downloads a prebuilt native library from a [c2pa-rs](https://github.com/contentauth/c2pa-rs) release. To test the Python bindings against a local, unreleased c2pa-rs checkout, you can instead build the native library from source.
+
+Prerequisites:
+
+- A local clone of [c2pa-rs](https://github.com/contentauth/c2pa-rs).
+- The [Rust toolchain](https://rust-lang.org/tools/install/) (`cargo` on your `PATH`).
+
+Point `C2PA_RS_PATH` at your c2pa-rs checkout and run the `build-from-source` target:
+
+```sh
+export C2PA_RS_PATH=/path/to/c2pa-rs
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH
+```
+
+This does a clean build of the `c2pa-c-ffi` crate (with the `file_io` feature, which the Python wrapper requires), stages the resulting library under both `artifacts/` and `src/c2pa/libs/`, and installs the package in editable mode, replacing any prebuilt artifacts from `make download-native-artifacts`. The release profile is used by default; to build the debug profile instead, pass `EXTRA_BUILD_ARGS="--debug"`:
+
+```sh
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH EXTRA_BUILD_ARGS="--debug"
+```
+
+### Note on targets for macOS
+
+On macOS this produces a universal (arm64+x86_64) library by default, which requires both Rust targets:
+
+```sh
+rustup target add aarch64-apple-darwin x86_64-apple-darwin
+```
+
+To build a single-architecture library instead, set `C2PA_LIBS_PLATFORM` to a specific platform (for example `aarch64-apple-darwin`).
+
 ## Examples
 
 See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:

{c2pa_python-0.32.12 → c2pa_python-0.32.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "c2pa-python"
-version = "0.32.12"
+version = "0.32.14"
 requires-python = ">=3.10"
 description = "Python bindings for the C2PA Content Authenticity Initiative (CAI) library"
 readme = { file = "README.md", content-type = "text/markdown" }

{c2pa_python-0.32.12 → c2pa_python-0.32.14}/src/c2pa/c2pa.py

@@ -48,6 +48,7 @@ _REQUIRED_FUNCTIONS = [
     'c2pa_reader_from_manifest_data_and_stream',
     'c2pa_reader_json',
     'c2pa_reader_detailed_json',
+    'c2pa_reader_crjson',
     'c2pa_reader_resource_to_stream',
     'c2pa_reader_from_context',
     'c2pa_reader_with_stream',
@@ -253,7 +254,8 @@ class ManagedResource:
         if self._lifecycle_state != LifecycleState.ACTIVE:
             raise C2paError(f"{name} is not properly initialized")
         if not self._handle:
-            raise C2paError(f"{name} has an invalid internal state (active but no handle)")
+            raise C2paError(
+                f"{name} has an invalid internal state (active but no handle)")
         _clear_error_state()
 
     def _release(self):
@@ -560,6 +562,9 @@ _setup_function(
 _setup_function(
     _lib.c2pa_reader_detailed_json, [
         ctypes.POINTER(C2paReader)], ctypes.c_void_p)
+_setup_function(
+    _lib.c2pa_reader_crjson, [
+        ctypes.POINTER(C2paReader)], ctypes.c_void_p)
 _setup_function(_lib.c2pa_reader_resource_to_stream, [ctypes.POINTER(
     C2paReader), ctypes.c_char_p, ctypes.POINTER(C2paStream)], ctypes.c_int64)
 _setup_function(
@@ -1011,7 +1016,11 @@ def _parse_operation_result_for_error(
     return None
 
 
-def _check_ffi_operation_result(result, fallback_msg, *, check=lambda r: not r):
+def _check_ffi_operation_result(
+        result,
+        fallback_msg,
+        *,
+        check=lambda r: not r):
     """Check an FFI native call result and raise C2paError if it indicates failure.
 
     Args:
@@ -1036,7 +1045,8 @@ def _check_ffi_operation_result(result, fallback_msg, *, check=lambda r: not r):
     return result
 
 
-def _to_utf8_bytes(data: Union[str, dict], error_context: str = "input") -> bytes:
+def _to_utf8_bytes(data: Union[str, dict],
+                   error_context: str = "input") -> bytes:
     """Convert a string or dict to UTF-8 bytes.
 
     If data is a dict, it is serialized to JSON first.
@@ -1059,8 +1069,8 @@ def _to_utf8_bytes(data: Union[str, dict], error_context: str = "input") -> byte
             raise C2paError.Json(f"Failed to serialize {error_context}: {e}")
     if not isinstance(data, str):
         raise C2paError.Encoding(
-            f"Expected str or dict for {error_context}, got {type(data).__name__}"
-        )
+            f"Expected str or dict for {error_context}, "
+            f"got {type(data).__name__}")
     try:
         return data.encode('utf-8')
     except UnicodeError as e:
@@ -1146,7 +1156,10 @@ def load_settings(settings: Union[str, dict], format: str = "json") -> None:
         raise C2paError(f"Failed to encode settings to UTF-8: {e}")
 
     result = _lib.c2pa_load_settings(settings_bytes, format_bytes)
-    _check_ffi_operation_result(result, "Error loading settings", check=lambda r: r != 0)
+    _check_ffi_operation_result(
+        result,
+        "Error loading settings",
+        check=lambda r: r != 0)
 
     return result
 
@@ -1219,7 +1232,8 @@ def read_ingredient_file(
     result = _lib.c2pa_read_ingredient_file(
         container._path_str, container._data_dir_str)
 
-    _check_ffi_operation_result(result, "Error reading ingredient file {}".format(path))
+    _check_ffi_operation_result(
+        result, "Error reading ingredient file {}".format(path))
 
     return _convert_to_py_string(result)
 
@@ -1258,7 +1272,8 @@ def read_file(path: Union[str, Path],
     container._data_dir_str = str(data_dir).encode('utf-8')
 
     result = _lib.c2pa_read_file(container._path_str, container._data_dir_str)
-    _check_ffi_operation_result(result, "Error during read of manifest from file {}".format(path))
+    _check_ffi_operation_result(
+        result, "Error during read of manifest from file {}".format(path))
 
     return _convert_to_py_string(result)
 
@@ -1419,7 +1434,6 @@ class Settings(ManagedResource):
     apply settings to Reader/Builder operations.
     """
 
-
     def __init__(self):
         """Create new Settings with default values."""
         super().__init__()
@@ -1516,7 +1530,6 @@ class Settings(ManagedResource):
         return self._handle
 
 
-
 class ContextBuilder:
     """Fluent builder for Context.
 
@@ -1574,7 +1587,6 @@ class Context(ManagedResource, ContextProvider):
     used directly again after that.
     """
 
-
     def __init__(
         self,
         settings: Optional['Settings'] = None,
@@ -1718,7 +1730,6 @@ class Context(ManagedResource, ContextProvider):
         return self._handle
 
 
-
 class Stream:
     # Class-level somewhat atomic counter for generating
     #  unique stream IDs (useful for tracing streams usage in debug)
@@ -2132,7 +2143,6 @@ class Reader(ManagedResource):
         Where `output` is either an in-memory stream or an opened file.
     """
 
-
     # Supported mimetypes cache
     _supported_mime_types_cache = None
 
@@ -2163,8 +2173,7 @@ class Reader(ManagedResource):
             C2paError: If there was an error retrieving the MIME types
         """
         result, cls._supported_mime_types_cache = _get_supported_mime_types(
-            _lib.c2pa_reader_supported_mime_types, cls._supported_mime_types_cache
-        )
+            _lib.c2pa_reader_supported_mime_types, cls._supported_mime_types_cache)
         return result
 
     @classmethod
@@ -2347,8 +2356,9 @@ class Reader(ManagedResource):
         else:
             if not isinstance(manifest_data, bytes):
                 raise TypeError(Reader._ERROR_MESSAGES['manifest_error'])
-            manifest_array = (ctypes.c_ubyte * len(manifest_data)).from_buffer_copy(
-                manifest_data)
+            manifest_array = (
+                ctypes.c_ubyte *
+                len(manifest_data)).from_buffer_copy(manifest_data)
             self._handle = (
                 _lib.c2pa_reader_from_manifest_data_and_stream(
                     format_bytes,
@@ -2358,9 +2368,9 @@ class Reader(ManagedResource):
                 )
             )
 
-        _check_ffi_operation_result(self._handle,
-            Reader._ERROR_MESSAGES['reader_error'].format("Unknown error")
-        )
+        _check_ffi_operation_result(
+            self._handle,
+            Reader._ERROR_MESSAGES['reader_error'].format("Unknown error"))
 
     def _init_from_file(self, path, format_bytes,
                         manifest_data=None):
@@ -2422,10 +2432,10 @@ class Reader(ManagedResource):
             )
             try:
                 _check_ffi_operation_result(reader_ptr,
-                    Reader._ERROR_MESSAGES[
-                        'reader_error'
-                    ].format("Unknown error")
-                )
+                                            Reader._ERROR_MESSAGES[
+                                                'reader_error'
+                                            ].format("Unknown error")
+                                            )
             except Exception:
                 if reader_ptr:
                     ManagedResource._free_native_ptr(reader_ptr)
@@ -2436,8 +2446,9 @@ class Reader(ManagedResource):
                     raise TypeError(
                         Reader._ERROR_MESSAGES[
                             'manifest_error'])
-                manifest_array = (ctypes.c_ubyte * len(manifest_data)).from_buffer_copy(
-                    manifest_data)
+                manifest_array = (
+                    ctypes.c_ubyte *
+                    len(manifest_data)).from_buffer_copy(manifest_data)
                 # Consume current reader,
                 # with manifest data and stream (C FFI pattern),
                 # to create a new one (switch out)
@@ -2462,10 +2473,10 @@ class Reader(ManagedResource):
             self._handle = new_ptr
 
             _check_ffi_operation_result(new_ptr,
-                Reader._ERROR_MESSAGES[
-                    'reader_error'
-                ].format("Unknown error")
-            )
+                                        Reader._ERROR_MESSAGES[
+                                            'reader_error'
+                                        ].format("Unknown error")
+                                        )
 
             self._lifecycle_state = LifecycleState.ACTIVE
         except Exception:
@@ -2556,9 +2567,9 @@ class Reader(ManagedResource):
             if not new_ptr:
                 self._mark_consumed()
             _check_ffi_operation_result(new_ptr,
-                Reader._ERROR_MESSAGES[
-                    'fragment_error'
-                ].format("Unknown error"))
+                                        Reader._ERROR_MESSAGES[
+                                            'fragment_error'
+                                        ].format("Unknown error"))
             self._handle = new_ptr
 
         # Invalidate caches: processing a new BMFF fragment updates the native
@@ -2594,7 +2605,7 @@ class Reader(ManagedResource):
 
         result = _lib.c2pa_reader_json(self._handle)
         _check_ffi_operation_result(result,
-            "Error during manifest parsing in Reader")
+                                    "Error during manifest parsing in Reader")
 
         # Cache the result and return it
         self._manifest_json_str_cache = _convert_to_py_string(result)
@@ -2619,8 +2630,29 @@ class Reader(ManagedResource):
         self._ensure_valid_state()
 
         result = _lib.c2pa_reader_detailed_json(self._handle)
-        _check_ffi_operation_result(result,
-            "Error during detailed manifest parsing in Reader")
+        _check_ffi_operation_result(
+            result, "Error during detailed manifest parsing in Reader")
+
+        return _convert_to_py_string(result)
+
+    def crjson(self) -> str:
+        """Get the manifest store as a crJSON string.
+
+        crJSON is a standardized JSON format for C2PA manifest data. This
+        call yields empty JSON ("{}") when there are no Content Credentials.
+
+        Returns:
+            The manifest store as a crJSON string.
+
+        Raises:
+            C2paError: If the Reader has been closed or the underlying C
+                      call returns null.
+        """
+
+        self._ensure_valid_state()
+
+        result = _lib.c2pa_reader_crjson(self._handle)
+        _check_ffi_operation_result(result, "Error parsing crJSON")
 
         return _convert_to_py_string(result)
 
@@ -2745,7 +2777,8 @@ class Reader(ManagedResource):
             result = _lib.c2pa_reader_resource_to_stream(
                 self._handle, uri_str, stream_obj._stream)
 
-            _check_ffi_operation_result(result,
+            _check_ffi_operation_result(
+                result,
                 "Error during resource {} to stream conversion".format(uri),
                 check=lambda r: r < 0)
 
@@ -2794,7 +2827,6 @@ class Reader(ManagedResource):
 class Signer(ManagedResource):
     """High-level wrapper for C2PA Signer operations."""
 
-
     # Class-level error messages to avoid multiple creation
     _ERROR_MESSAGES = {
         'closed_error': "Signer is closed",
@@ -2827,8 +2859,8 @@ class Signer(ManagedResource):
 
         signer_ptr = _lib.c2pa_signer_from_info(ctypes.byref(signer_info))
 
-        _check_ffi_operation_result(signer_ptr,
-            "Failed to create signer from configured signer_info")
+        _check_ffi_operation_result(
+            signer_ptr, "Failed to create signer from configured signer_info")
 
         return cls(signer_ptr)
 
@@ -2959,7 +2991,7 @@ class Signer(ManagedResource):
         )
 
         _check_ffi_operation_result(signer_ptr,
-            "Failed to create signer")
+                                    "Failed to create signer")
 
         # Create and return the signer instance with the callback
         signer_instance = cls(signer_ptr)
@@ -3009,8 +3041,10 @@ class Signer(ManagedResource):
 
         result = _lib.c2pa_signer_reserve_size(self._handle)
 
-        _check_ffi_operation_result(result,
-            "Failed to get reserve size", check=lambda r: r < 0)
+        _check_ffi_operation_result(
+            result,
+            "Failed to get reserve size",
+            check=lambda r: r < 0)
 
         return result
 
@@ -3018,7 +3052,6 @@ class Signer(ManagedResource):
 class Builder(ManagedResource):
     """High-level wrapper for C2PA Builder operations."""
 
-
     # Supported mimetypes cache
     _supported_mime_types_cache = None
 
@@ -3051,8 +3084,7 @@ class Builder(ManagedResource):
             C2paError: If there was an error retrieving the MIME types
         """
         result, cls._supported_mime_types_cache = _get_supported_mime_types(
-            _lib.c2pa_builder_supported_mime_types, cls._supported_mime_types_cache
-        )
+            _lib.c2pa_builder_supported_mime_types, cls._supported_mime_types_cache)
         return result
 
     @classmethod
@@ -3125,8 +3157,8 @@ class Builder(ManagedResource):
             )
 
             _check_ffi_operation_result(builder._handle,
-                "Failed to create builder from archive"
-            )
+                                        "Failed to create builder from archive"
+                                        )
 
             builder._lifecycle_state = LifecycleState.ACTIVE
             return builder
@@ -3178,11 +3210,9 @@ class Builder(ManagedResource):
         else:
             self._handle = _lib.c2pa_builder_from_json(json_str)
 
-            _check_ffi_operation_result(self._handle,
-                Builder._ERROR_MESSAGES['builder_error'].format(
-                    "Unknown error"
-                )
-            )
+            _check_ffi_operation_result(
+                self._handle,
+                Builder._ERROR_MESSAGES['builder_error'].format("Unknown error"))
 
         self._lifecycle_state = LifecycleState.ACTIVE
 
@@ -3200,10 +3230,10 @@ class Builder(ManagedResource):
         )
         try:
             _check_ffi_operation_result(builder_ptr,
-                Builder._ERROR_MESSAGES[
-                    'builder_error'
-                ].format("Unknown error")
-            )
+                                        Builder._ERROR_MESSAGES[
+                                            'builder_error'
+                                        ].format("Unknown error")
+                                        )
         except Exception:
             if builder_ptr:
                 ManagedResource._free_native_ptr(builder_ptr)
@@ -3215,10 +3245,10 @@ class Builder(ManagedResource):
         self._handle = new_ptr
 
         _check_ffi_operation_result(new_ptr,
-            Builder._ERROR_MESSAGES[
-                    'builder_error'
-                ].format("Unknown error")
-            )
+                                    Builder._ERROR_MESSAGES[
+                                        'builder_error'
+                                    ].format("Unknown error")
+                                    )
 
     def set_no_embed(self):
         """Set the no-embed flag.
@@ -3247,7 +3277,8 @@ class Builder(ManagedResource):
         url_bytes = _to_utf8_bytes(remote_url, "remote URL")
         result = _lib.c2pa_builder_set_remote_url(self._handle, url_bytes)
 
-        _check_ffi_operation_result(result,
+        _check_ffi_operation_result(
+            result,
             Builder._ERROR_MESSAGES['url_error'].format("Unknown error"),
             check=lambda r: r != 0)
 
@@ -3285,7 +3316,8 @@ class Builder(ManagedResource):
             ctypes.c_uint(digital_source_type),
         )
 
-        _check_ffi_operation_result(result,
+        _check_ffi_operation_result(
+            result,
             "Error setting intent for Builder: Unknown error",
             check=lambda r: r != 0)
 
@@ -3307,10 +3339,9 @@ class Builder(ManagedResource):
             result = _lib.c2pa_builder_add_resource(
                 self._handle, uri_bytes, stream_obj._stream)
 
-            _check_ffi_operation_result(result,
-                Builder._ERROR_MESSAGES['resource_error'].format(
-                    "Unknown error"
-                ),
+            _check_ffi_operation_result(
+                result,
+                Builder._ERROR_MESSAGES['resource_error'].format("Unknown error"),
                 check=lambda r: r != 0)
 
     def add_ingredient(
@@ -3375,10 +3406,9 @@ class Builder(ManagedResource):
                 )
             )
 
-            _check_ffi_operation_result(result,
-                Builder._ERROR_MESSAGES['ingredient_error'].format(
-                    "Unknown error"
-                ),
+            _check_ffi_operation_result(
+                result,
+                Builder._ERROR_MESSAGES['ingredient_error'].format("Unknown error"),
                 check=lambda r: r != 0)
 
     def add_ingredient_from_file_path(
@@ -3444,10 +3474,9 @@ class Builder(ManagedResource):
         action_str = _to_utf8_bytes(action_json, "action JSON")
         result = _lib.c2pa_builder_add_action(self._handle, action_str)
 
-        _check_ffi_operation_result(result,
-            Builder._ERROR_MESSAGES['action_error'].format(
-                "Unknown error"
-            ),
+        _check_ffi_operation_result(
+            result,
+            Builder._ERROR_MESSAGES['action_error'].format("Unknown error"),
             check=lambda r: r != 0)
 
     def to_archive(self, stream: Any) -> None:
@@ -3466,10 +3495,9 @@ class Builder(ManagedResource):
             result = _lib.c2pa_builder_to_archive(
                 self._handle, stream_obj._stream)
 
-            _check_ffi_operation_result(result,
-                Builder._ERROR_MESSAGES["archive_error"].format(
-                    "Unknown error"
-                ),
+            _check_ffi_operation_result(
+                result,
+                Builder._ERROR_MESSAGES["archive_error"].format("Unknown error"),
                 check=lambda r: r != 0)
 
     def with_archive(self, stream: Any) -> 'Builder':
@@ -3491,7 +3519,8 @@ class Builder(ManagedResource):
 
         with Stream(stream) as stream_obj:
             try:
-                new_ptr = _lib.c2pa_builder_with_archive(self._handle, stream_obj._stream)
+                new_ptr = _lib.c2pa_builder_with_archive(
+                    self._handle, stream_obj._stream)
             except Exception as e:
                 self._mark_consumed()
                 raise C2paError(
@@ -3499,7 +3528,8 @@ class Builder(ManagedResource):
                 )
             # Old handle consumed by FFI
             self._handle = new_ptr
-            _check_ffi_operation_result(new_ptr, "Failed to load archive into builder")
+            _check_ffi_operation_result(
+                new_ptr, "Failed to load archive into builder")
 
         return self
 
@@ -3566,8 +3596,10 @@ class Builder(ManagedResource):
             self.close()
             raise C2paError(f"Error during signing: {e}")
 
-        _check_ffi_operation_result(result,
-            "Error during signing", check=lambda r: r < 0)
+        _check_ffi_operation_result(
+            result,
+            "Error during signing",
+            check=lambda r: r < 0)
 
         # Capture the manifest bytes if available
         manifest_bytes = b""
@@ -3623,7 +3655,8 @@ class Builder(ManagedResource):
                         signer=signer,
                     )
                 elif self._has_context_signer:
-                    manifest_bytes = self._sign_internal(format, source_stream, dest_stream)
+                    manifest_bytes = self._sign_internal(
+                        format, source_stream, dest_stream)
                 else:
                     raise C2paError(
                         "No signer provided. Either pass a"
@@ -3792,8 +3825,10 @@ def format_embeddable(format: str, manifest_bytes: bytes) -> tuple[int, bytes]:
         ctypes.byref(result_bytes_ptr)
     )
 
-    _check_ffi_operation_result(result,
-        "Failed to format embeddable manifest", check=lambda r: r < 0)
+    _check_ffi_operation_result(
+        result,
+        "Failed to format embeddable manifest",
+        check=lambda r: r < 0)
 
     size = result
     try:
@@ -3924,7 +3959,7 @@ def ed25519_sign(data: bytes, private_key: str) -> bytes:
         )
 
         _check_ffi_operation_result(signature_ptr,
-            "Failed to sign data with Ed25519")
+                                    "Failed to sign data with Ed25519")
 
         try:
             # Ed25519 signatures are always 64 bytes

{c2pa_python-0.32.12 → c2pa_python-0.32.14/src/c2pa_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.32.12
+Version: 0.32.14
 Summary: Python bindings for the C2PA Content Authenticity Initiative (CAI) library
 Author-email: Gavin Peacock <gvnpeacock@adobe.com>, Tania Mathern <mathern@adobe.com>
 Maintainer-email: Gavin Peacock <gpeacock@adobe.com>
@@ -69,6 +69,48 @@ To use the module in Python code, import the module like this:
 import c2pa
 ```
 
+## Building from local c2pa-rs sources
+
+### Using a virtual environment with local builds
+
+The `make` targets honor an active virtualenv. Create a virtual environment `./.venv` and activate it before running them so commands use the project interpreter rather than the global Python interpreter:
+
+```sh
+make create-venv && source .venv/bin/activate
+```
+
+### Build steps
+
+By default the build downloads a prebuilt native library from a [c2pa-rs](https://github.com/contentauth/c2pa-rs) release. To test the Python bindings against a local, unreleased c2pa-rs checkout, you can instead build the native library from source.
+
+Prerequisites:
+
+- A local clone of [c2pa-rs](https://github.com/contentauth/c2pa-rs).
+- The [Rust toolchain](https://rust-lang.org/tools/install/) (`cargo` on your `PATH`).
+
+Point `C2PA_RS_PATH` at your c2pa-rs checkout and run the `build-from-source` target:
+
+```sh
+export C2PA_RS_PATH=/path/to/c2pa-rs
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH
+```
+
+This does a clean build of the `c2pa-c-ffi` crate (with the `file_io` feature, which the Python wrapper requires), stages the resulting library under both `artifacts/` and `src/c2pa/libs/`, and installs the package in editable mode, replacing any prebuilt artifacts from `make download-native-artifacts`. The release profile is used by default; to build the debug profile instead, pass `EXTRA_BUILD_ARGS="--debug"`:
+
+```sh
+make build-from-source C2PA_RS_PATH=$C2PA_RS_PATH EXTRA_BUILD_ARGS="--debug"
+```
+
+### Note on targets for macOS
+
+On macOS this produces a universal (arm64+x86_64) library by default, which requires both Rust targets:
+
+```sh
+rustup target add aarch64-apple-darwin x86_64-apple-darwin
+```
+
+To build a single-architecture library instead, set `C2PA_LIBS_PLATFORM` to a specific platform (for example `aarch64-apple-darwin`).
+
 ## Examples
 
 See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:

{c2pa_python-0.32.12 → c2pa_python-0.32.14}/tests/test_unit_tests.py

@@ -67,10 +67,25 @@ def load_test_settings_json():
     return settings_data
 
 
+def parse_native_version():
+    """
+    Parse the expected native SDK version from c2pa-native-version.txt.
+
+    Returns:
+        str: The semantic version string (e.g. "0.85.2").
+    """
+    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    version_path = os.path.join(repo_root, 'c2pa-native-version.txt')
+    with open(version_path, 'r') as f:
+        raw = f.read().strip()
+    # Strip the "c2pa-v" prefix to get the bare semantic version.
+    return raw.split('v', 1)[1] if 'v' in raw else raw
+
+
 class TestC2paSdk(unittest.TestCase):
     def test_sdk_version(self):
         # This test verifies the native libraries used match the expected version.
-        self.assertIn("0.85.1", sdk_version())
+        self.assertIn(parse_native_version(), sdk_version())
 
 
 class TestReader(unittest.TestCase):
@@ -256,6 +271,19 @@ class TestReader(unittest.TestCase):
             title = manifest_store["manifests"][manifest_store["active_manifest"]]["claim"]["dc:title"]
             self.assertEqual(title, DEFAULT_TEST_FILE_NAME)
 
+    def test_stream_read_crjson_and_parse(self):
+        with open(self.testPath, "rb") as file:
+            reader = Reader("image/jpeg", file)
+            crjson = reader.crjson()
+            self.assertTrue(crjson)
+            json.loads(crjson)
+
+    def test_stream_read_crjson_path_only(self):
+        with Reader(self.testPath) as reader:
+            crjson = reader.crjson()
+            self.assertTrue(crjson)
+            json.loads(crjson)
+
     def test_stream_read_string_stream_path_only(self):
         with Reader(self.testPath) as reader:
             json_data = reader.json()