c2pa-python 0.25.0__tar.gz → 0.27.0__tar.gz

{c2pa_python-0.25.0/src/c2pa_python.egg-info → c2pa_python-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.25.0
+Version: 0.27.0
 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>

{c2pa_python-0.25.0 → c2pa_python-0.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "c2pa-python"
-version = "0.25.0"
+version = "0.27.0"
 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.25.0 → c2pa_python-0.27.0}/src/c2pa/c2pa.py

@@ -49,6 +49,7 @@ _REQUIRED_FUNCTIONS = [
     'c2pa_builder_set_remote_url',
     'c2pa_builder_add_resource',
     'c2pa_builder_add_ingredient_from_stream',
+    'c2pa_builder_add_action',
     'c2pa_builder_to_archive',
     'c2pa_builder_sign',
     'c2pa_manifest_bytes_free',
@@ -403,6 +404,9 @@ _setup_function(_lib.c2pa_builder_add_ingredient_from_stream,
                  ctypes.c_char_p,
                  ctypes.POINTER(C2paStream)],
                 ctypes.c_int)
+_setup_function(_lib.c2pa_builder_add_action,
+                [ctypes.POINTER(C2paBuilder), ctypes.c_char_p],
+                ctypes.c_int)
 _setup_function(_lib.c2pa_builder_to_archive,
                 [ctypes.POINTER(C2paBuilder), ctypes.POINTER(C2paStream)],
                 ctypes.c_int)
@@ -667,20 +671,44 @@ def version() -> str:
     return _convert_to_py_string(result)
 
 
+@overload
 def load_settings(settings: str, format: str = "json") -> None:
-    """Load C2PA settings from a string.
+    ...
+
+
+@overload
+def load_settings(settings: dict) -> None:
+    ...
+
+
+def load_settings(settings: Union[str, dict], format: str = "json") -> None:
+    """Load C2PA settings from a string or dict.
 
     Args:
-        settings: The settings string to load
-        format: The format of the settings string (default: "json")
+        settings: The settings string or dict to load
+        format: The format of the settings string (default: "json").
+                Ignored when settings is a dict.
 
     Raises:
         C2paError: If there was an error loading the settings
     """
-    result = _lib.c2pa_load_settings(
-        settings.encode('utf-8'),
-        format.encode('utf-8')
-    )
+    # Convert to JSON string as necessary
+    try:
+        if isinstance(settings, dict):
+            settings_str = json.dumps(settings)
+            format = "json"
+        else:
+            settings_str = settings
+    except (TypeError, ValueError) as e:
+        raise C2paError(f"Failed to serialize settings to JSON: {e}")
+
+    try:
+        settings_bytes = settings_str.encode('utf-8')
+        format_bytes = format.encode('utf-8')
+    except (AttributeError, UnicodeEncodeError) as e:
+        raise C2paError(f"Failed to encode settings to UTF-8: {e}")
+
+    result = _lib.c2pa_load_settings(settings_bytes, format_bytes)
     if result != 0:
         error = _parse_operation_result_for_error(_lib.c2pa_error())
         if error:
@@ -1358,6 +1386,10 @@ class Reader:
         # we may have opened ourselves, and that we need to close later
         self._backing_file = None
 
+        # Caches for manifest JSON string and parsed data
+        self._manifest_json_str_cache = None
+        self._manifest_data_cache = None
+
         if stream is None:
             # If we don't get a stream as param:
             # Create a stream from the file path in format_or_path
@@ -1600,6 +1632,33 @@ class Reader:
             # Ensure we don't raise exceptions during cleanup
             pass
 
+    def _get_cached_manifest_data(self) -> Optional[dict]:
+        """Get the cached manifest data, fetching and parsing if not cached.
+
+        Returns:
+            A dictionary containing the parsed manifest data, or None if
+            JSON parsing fails
+
+        Raises:
+            C2paError: If there was an error getting the JSON
+        """
+        if self._manifest_data_cache is None:
+            if self._manifest_json_str_cache is None:
+                self._manifest_json_str_cache = self.json()
+
+            try:
+                self._manifest_data_cache = json.loads(
+                    self._manifest_json_str_cache
+                )
+            except json.JSONDecodeError:
+                # Reset cache to reattempt read, possibly
+                self._manifest_data_cache = None
+                self._manifest_json_str_cache = None
+                # Failed to parse manifest JSON
+                return None
+
+        return self._manifest_data_cache
+
     def close(self):
         """Release the reader resources.
 
@@ -1620,6 +1679,9 @@ class Reader:
                 Reader._ERROR_MESSAGES['cleanup_error'].format(
                     str(e)))
         finally:
+            # Clear the cache when closing
+            self._manifest_json_str_cache = None
+            self._manifest_data_cache = None
             self._closed = True
 
     def json(self) -> str:
@@ -1634,6 +1696,10 @@ class Reader:
 
         self._ensure_valid_state()
 
+        # Return cached result if available
+        if self._manifest_json_str_cache is not None:
+            return self._manifest_json_str_cache
+
         result = _lib.c2pa_reader_json(self._reader)
 
         if result is None:
@@ -1642,7 +1708,128 @@ class Reader:
                 raise C2paError(error)
             raise C2paError("Error during manifest parsing in Reader")
 
-        return _convert_to_py_string(result)
+        # Cache the result and return it
+        self._manifest_json_str_cache = _convert_to_py_string(result)
+        return self._manifest_json_str_cache
+
+    def get_active_manifest(self) -> Optional[dict]:
+        """Get the active manifest from the manifest store.
+
+        This method retrieves the full manifest JSON and extracts the active
+        manifest based on the active_manifest key.
+
+        Returns:
+            A dictionary containing the active manifest data, including claims,
+            assertions, ingredients, and signature information, or None if no
+            manifest is found or if there was an error parsing the JSON.
+
+        Raises:
+            KeyError: If the active_manifest key is missing from the JSON
+        """
+        try:
+            # Get cached manifest data
+            manifest_data = self._get_cached_manifest_data()
+            if manifest_data is None:
+                # raise C2paError("Failed to parse manifest JSON")
+                return None
+
+            # Get the active manfiest id/label
+            if "active_manifest" not in manifest_data:
+                raise KeyError("No 'active_manifest' key found")
+
+            active_manifest_id = manifest_data["active_manifest"]
+
+            # Retrieve the active manifest data using manifest id/label
+            if "manifests" not in manifest_data:
+                raise KeyError("No 'manifests' key found in manifest data")
+
+            manifests = manifest_data["manifests"]
+            if active_manifest_id not in manifests:
+                raise KeyError("Active manifest not found in manifest store")
+
+            return manifests[active_manifest_id]
+        except C2paError.ManifestNotFound:
+            return None
+
+    def get_manifest(self, label: str) -> Optional[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,
+            or None if no manifest is found or if there was an error parsing
+            the JSON.
+
+        Raises:
+            KeyError: If the manifests key is missing from the JSON
+        """
+        try:
+            # Get cached manifest data
+            manifest_data = self._get_cached_manifest_data()
+            if manifest_data is None:
+                # raise C2paError("Failed to parse manifest JSON")
+                return None
+
+            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(f"Manifest {label} not found in manifest store")
+
+            return manifests[label]
+        except C2paError.ManifestNotFound:
+            return None
+
+    def get_validation_state(self) -> Optional[str]:
+        """Get the validation state of the manifest store.
+
+        This method retrieves the full manifest JSON and extracts the
+        validation_state field, which indicates the overall validation
+        status of the C2PA manifest.
+
+        Returns:
+            The validation state as a string,
+            or None if the validation_state field is not present or if no
+            manifest is found or if there was an error parsing the JSON.
+        """
+        try:
+            # Get cached manifest data
+            manifest_data = self._get_cached_manifest_data()
+            if manifest_data is None:
+                return None
+
+            return manifest_data.get("validation_state")
+        except C2paError.ManifestNotFound:
+            return None
+
+    def get_validation_results(self) -> Optional[dict]:
+        """Get the validation results of the manifest store.
+
+        This method retrieves the full manifest JSON and extracts
+        the validation_results object, which contains detailed
+        validation information.
+
+        Returns:
+            The validation results as a dictionary containing
+            validation details, or None if the validation_results
+            field is not present or if no manifest is found or if
+            there was an error parsing the JSON.
+        """
+        try:
+            # Get cached manifest data
+            manifest_data = self._get_cached_manifest_data()
+            if manifest_data is None:
+                return None
+
+            return manifest_data.get("validation_results")
+        except C2paError.ManifestNotFound:
+            return None
 
     def resource_to_stream(self, uri: str, stream: Any) -> int:
         """Write a resource to a stream.
@@ -2039,6 +2226,7 @@ class Builder:
         'url_error': "Error setting remote URL: {}",
         'resource_error': "Error adding resource: {}",
         'ingredient_error': "Error adding ingredient: {}",
+        'action_error': "Error adding action: {}",
         'archive_error': "Error writing archive: {}",
         'sign_error': "Error during signing: {}",
         'encoding_error': "Invalid UTF-8 characters in manifest: {}",
@@ -2336,13 +2524,16 @@ class Builder:
                     )
                 )
 
-    def add_ingredient(self, ingredient_json: str, format: str, source: Any):
+    def add_ingredient(
+        self, ingredient_json: Union[str, dict], format: str, source: Any
+    ):
         """Add an ingredient to the builder (facade method).
         The added ingredient's source should be a stream-like object
         (for instance, a file opened as stream).
 
         Args:
             ingredient_json: The JSON ingredient definition
+                (either a JSON string or a dictionary)
             format: The MIME type or extension of the ingredient
             source: The stream containing the ingredient data
               (any Python stream-like object)
@@ -2362,7 +2553,7 @@ class Builder:
 
     def add_ingredient_from_stream(
             self,
-            ingredient_json: str,
+            ingredient_json: Union[str, dict],
             format: str,
             source: Any):
         """Add an ingredient from a stream to the builder.
@@ -2370,6 +2561,7 @@ class Builder:
 
         Args:
             ingredient_json: The JSON ingredient definition
+                (either a JSON string or a dictionary)
             format: The MIME type or extension of the ingredient
             source: The stream containing the ingredient data
               (any Python stream-like object)
@@ -2381,6 +2573,9 @@ class Builder:
         """
         self._ensure_valid_state()
 
+        if isinstance(ingredient_json, dict):
+            ingredient_json = json.dumps(ingredient_json)
+
         try:
             ingredient_str = ingredient_json.encode('utf-8')
             format_str = format.encode('utf-8')
@@ -2411,7 +2606,7 @@ class Builder:
 
     def add_ingredient_from_file_path(
             self,
-            ingredient_json: str,
+            ingredient_json: Union[str, dict],
             format: str,
             filepath: Union[str, Path]):
         """Add an ingredient from a file path to the builder (deprecated).
@@ -2423,6 +2618,7 @@ class Builder:
 
         Args:
             ingredient_json: The JSON ingredient definition
+                (either a JSON string or a dictionary)
             format: The MIME type or extension of the ingredient
             filepath: The path to the file containing the ingredient data
               (can be a string or Path object)
@@ -2454,6 +2650,42 @@ class Builder:
         except Exception as e:
             raise C2paError.Other(f"Could not add ingredient: {e}") from e
 
+    def add_action(self, action_json: Union[str, dict]) -> None:
+        """Add an action to the builder, that will be placed
+        in the actions assertion array in the generated manifest.
+
+        Args:
+            action_json: The JSON action definition
+                (either a JSON string or a dictionary)
+
+        Raises:
+            C2paError: If there was an error adding the action
+            C2paError.Encoding: If the action JSON contains invalid UTF-8 chars
+        """
+        self._ensure_valid_state()
+
+        if isinstance(action_json, dict):
+            action_json = json.dumps(action_json)
+
+        try:
+            action_str = action_json.encode('utf-8')
+        except UnicodeError as e:
+            raise C2paError.Encoding(
+                Builder._ERROR_MESSAGES['encoding_error'].format(str(e))
+            )
+
+        result = _lib.c2pa_builder_add_action(self._builder, action_str)
+
+        if result != 0:
+            error = _parse_operation_result_for_error(_lib.c2pa_error())
+            if error:
+                raise C2paError(error)
+            raise C2paError(
+                Builder._ERROR_MESSAGES['action_error'].format(
+                    "Unknown error"
+                )
+            )
+
     def to_archive(self, stream: Any) -> None:
         """Write an archive of the builder to a stream.
 

{c2pa_python-0.25.0 → c2pa_python-0.27.0/src/c2pa_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.25.0
+Version: 0.27.0
 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>