c2pa-python 0.16.0__tar.gz → 0.18.0__tar.gz

{c2pa_python-0.16.0/src/c2pa_python.egg-info → c2pa_python-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.16.0
+Version: 0.18.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.16.0 → c2pa_python-0.18.0}/pyproject.toml

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

@@ -14,6 +14,7 @@
 import ctypes
 import enum
 import json
+import logging
 import sys
 import os
 import warnings
@@ -23,6 +24,10 @@ import io
 from .lib import dynamically_load_library
 import mimetypes
 
+# Create a module-specific logger
+logger = logging.getLogger("c2pa")
+logger.addHandler(logging.NullHandler())
+
 # Define required function names
 _REQUIRED_FUNCTIONS = [
     'c2pa_version',
@@ -255,6 +260,12 @@ class C2paSignerInfo(ctypes.Structure):
             private_key: The private key as a string
             ta_url: The timestamp authority URL as bytes
         """
+
+        if sign_cert is None:
+            raise ValueError("sign_cert must be set")
+        if private_key is None:
+            raise ValueError("private_key must be set")
+
         # Handle alg parameter: can be C2paSigningAlg enum
         # or string (or bytes), convert as needed
         if isinstance(alg, C2paSigningAlg):
@@ -545,19 +556,31 @@ def _convert_to_py_string(value) -> str:
         return ""
 
     py_string = ""
-    ptr = ctypes.cast(value, ctypes.c_char_p)
 
-    # Only if we got a valid pointer
-    if ptr and ptr.value is not None:
-        try:
-            py_string = ptr.value.decode('utf-8', errors='replace')
-        except Exception:
-            py_string = ""
+    # Validate pointer before casting and freeing
+    if not isinstance(value, (int, ctypes.c_void_p)) or value == 0:
+        return ""
 
-        # Free the Rust-allocated memory
-        _lib.c2pa_string_free(value)
+    try:
+        ptr = ctypes.cast(value, ctypes.c_char_p)
+
+        # Only if we got a valid pointer with valid content
+        if ptr and ptr.value is not None:
+            try:
+                py_string = ptr.value.decode('utf-8', errors='replace')
+            except Exception:
+                py_string = ""
+            finally:
+                # Only free if we have a valid pointer
+                try:
+                    _lib.c2pa_string_free(value)
+                except Exception:
+                    # Ignore clean up issues
+                    pass
+    except (ctypes.ArgumentError, TypeError, ValueError):
+        # Invalid pointer type or value
+        return ""
 
-    # In case of invalid pointer, no free (avoids double-free)
     return py_string
 
 
@@ -617,7 +640,7 @@ def sdk_version() -> str:
     Returns the underlying c2pa-rs/c2pa-c-ffi version string
     """
     vstr = version()
-    # Example: "c2pa-c/0.49.5 c2pa-rs/0.49.5"
+    # Example: "c2pa-c/0.60.1 c2pa-rs/0.60.1"
     for part in vstr.split():
         if part.startswith("c2pa-rs/"):
             return part.split("/", 1)[1]
@@ -654,6 +677,33 @@ def load_settings(settings: str, format: str = "json") -> None:
     return result
 
 
+def _get_mime_type_from_path(path: Union[str, Path]) -> str:
+    """Attempt to guess the MIME type from a file path (with extension).
+
+    Args:
+        path: File path as string or Path object
+
+    Returns:
+        MIME type string
+
+    Raises:
+        C2paError.NotSupported: If MIME type cannot be determined
+    """
+    path_obj = Path(path)
+    file_extension = path_obj.suffix.lower() if path_obj.suffix else ""
+
+    if file_extension == ".dng":
+        # mimetypes guesses the wrong type for dng,
+        # so we bypass it and set the correct type
+        return "image/dng"
+    else:
+        mime_type = mimetypes.guess_type(str(path))[0]
+        if not mime_type:
+            raise C2paError.NotSupported(
+                f"Could not determine MIME type for file: {path}")
+        return mime_type
+
+
 def read_ingredient_file(
         path: Union[str, Path], data_dir: Union[str, Path]) -> str:
     """Read a file as C2PA ingredient.
@@ -803,7 +853,9 @@ def sign_file(
         Use :meth:`Builder.sign` instead.
 
     Args:
-        source_path: Path to the source file
+        source_path: Path to the source file. We will attempt
+              to guess the mimetype of the source file based on
+              the extension.
         dest_path: Path to write the signed file to
         manifest: The manifest JSON string
         signer_or_info: Either a signer configuration or a signer object
@@ -860,6 +912,7 @@ def sign_file(
             try:
                 os.remove(dest_path)
             except OSError:
+                logger.warning("Failed to remove destination file")
                 pass  # Ignore cleanup errors
 
         # Re-raise the error
@@ -1097,9 +1150,30 @@ class Stream:
         self.close()
 
     def __del__(self):
-        """Ensure resources are cleaned up if close() wasn't called."""
-        if hasattr(self, '_closed'):
-            self.close()
+        """Ensure resources are cleaned up if close()wasn't called.
+
+        This destructor only cleans up if the object
+        hasn't been explicitly closed.
+        """
+        try:
+            # Only cleanup if not already closed and we have a valid stream
+            if hasattr(self, '_closed') and not self._closed:
+                if hasattr(self, '_stream') and self._stream:
+                    # Use internal cleanup to avoid calling close() which could
+                    # cause issues
+                    try:
+                        _lib.c2pa_release_stream(self._stream)
+                    except Exception:
+                        # Destructors shouldn't raise exceptions
+                        logger.error("Failed to release Stream")
+                        pass
+                    finally:
+                        self._stream = None
+                        self._closed = True
+                        self._initialized = False
+        except Exception:
+            # Destructors must not raise exceptions
+            pass
 
     def close(self):
         """Release the stream resources.
@@ -1121,9 +1195,9 @@ class Stream:
                 try:
                     _lib.c2pa_release_stream(self._stream)
                 except Exception as e:
-                    print(
+                    logger.error(
                         Stream._ERROR_MESSAGES['stream_error'].format(
-                            str(e)), file=sys.stderr)
+                            str(e)))
                 finally:
                     self._stream = None
 
@@ -1133,14 +1207,14 @@ class Stream:
                     try:
                         setattr(self, attr, None)
                     except Exception as e:
-                        print(
+                        logger.error(
                             Stream._ERROR_MESSAGES['callback_error'].format(
-                                attr, str(e)), file=sys.stderr)
+                                attr, str(e)))
 
         except Exception as e:
-            print(
+            logger.error(
                 Stream._ERROR_MESSAGES['cleanup_error'].format(
-                    str(e)), file=sys.stderr)
+                    str(e)))
         finally:
             self._closed = True
             self._initialized = False
@@ -1184,26 +1258,71 @@ class Reader:
         'stream_error': "Error cleaning up stream: {}",
         'file_error': "Error cleaning up file: {}",
         'reader_cleanup_error': "Error cleaning up reader: {}",
-        'encoding_error': "Invalid UTF-8 characters in input: {}"
+        'encoding_error': "Invalid UTF-8 characters in input: {}",
+        'closed_error': "Reader is closed"
     }
 
     @classmethod
     def get_supported_mime_types(cls) -> list[str]:
+        """Get the list of supported MIME types for the Reader.
+        This method retrieves supported MIME types from the native library.
+
+        Returns:
+            List of supported MIME type strings
+
+        Raises:
+            C2paError: If there was an error retrieving the MIME types
+        """
         if cls._supported_mime_types_cache is not None:
             return cls._supported_mime_types_cache
 
         count = ctypes.c_size_t()
         arr = _lib.c2pa_reader_supported_mime_types(ctypes.byref(count))
 
+        # Validate the returned array pointer
+        if not arr:
+            # If no array returned, check for errors
+            error = _parse_operation_result_for_error(_lib.c2pa_error())
+            if error:
+                raise C2paError(f"Failed to get supported MIME types: {error}")
+            # Return empty list if no error but no array
+            return []
+
+        # Validate count value
+        if count.value <= 0:
+            # Free the array even if count is invalid
+            try:
+                _lib.c2pa_free_string_array(arr, count.value)
+            except Exception:
+                pass
+            return []
+
         try:
-            # CDecode values to place them in Python managed memory
-            result = [arr[i].decode("utf-8") for i in range(count.value)]
+            result = []
+            for i in range(count.value):
+                try:
+                    # Validate each array element before accessing
+                    if arr[i] is None:
+                        continue
+
+                    mime_type = arr[i].decode("utf-8", errors='replace')
+                    if mime_type:
+                        result.append(mime_type)
+                except Exception:
+                    # Ignore cleanup errors
+                    continue
         finally:
-            # Release native memory, as per API contract
-            # c2pa_reader_supported_mime_types must call c2pa_free_string_array
-            _lib.c2pa_free_string_array(arr, count.value)
+            # Always free the native memory, even if string extraction fails
+            try:
+                _lib.c2pa_free_string_array(arr, count.value)
+            except Exception:
+                # Ignore cleanup errors
+                pass
+
+        # Cache the result
+        if result:
+            cls._supported_mime_types_cache = result
 
-        cls._supported_mime_types_cache = result
         return cls._supported_mime_types_cache
 
     def __init__(self,
@@ -1224,15 +1343,20 @@ class Reader:
               contain invalid UTF-8 characters
         """
 
+        self._closed = False
+
         self._reader = None
         self._own_stream = None
 
+        # This is used to keep track of a file
+        # we may have opened ourselves, and that we need to close later
+        self._backing_file = 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
             path = str(format_or_path)
-            mime_type = mimetypes.guess_type(
-                path)[0]
+            mime_type = _get_mime_type_from_path(path)
 
             if not mime_type:
                 raise C2paError.NotSupported(
@@ -1243,7 +1367,7 @@ class Reader:
                     f"Reader does not support {mime_type}")
 
             try:
-                self._mime_type_str = mime_type.encode('utf-8')
+                mime_type_str = mime_type.encode('utf-8')
             except UnicodeError as e:
                 raise C2paError.Encoding(
                     Reader._ERROR_MESSAGES['encoding_error'].format(
@@ -1255,7 +1379,7 @@ class Reader:
                 self._own_stream = Stream(file)
 
                 self._reader = _lib.c2pa_reader_from_stream(
-                    self._mime_type_str,
+                    mime_type_str,
                     self._own_stream._stream
                 )
 
@@ -1273,13 +1397,13 @@ class Reader:
                     )
 
                 # Store the file to close it later
-                self._file_like_stream = file
+                self._backing_file = file
 
             except Exception as e:
                 if self._own_stream:
                     self._own_stream.close()
-                if hasattr(self, '_file_like_stream'):
-                    self._file_like_stream.close()
+                if hasattr(self, '_backing_file') and self._backing_file:
+                    self._backing_file.close()
                 raise C2paError.Io(
                     Reader._ERROR_MESSAGES['io_error'].format(
                         str(e)))
@@ -1288,7 +1412,7 @@ class Reader:
             # If stream is a string, treat it as a path and try to open it
 
             # format_or_path is a format
-            if format_or_path not in Reader.get_supported_mime_types():
+            if format_or_path.lower() not in Reader.get_supported_mime_types():
                 raise C2paError.NotSupported(
                     f"Reader does not support {format_or_path}")
 
@@ -1297,11 +1421,11 @@ class Reader:
                 self._own_stream = Stream(file)
 
                 format_str = str(format_or_path)
-                self._format_str = format_str.encode('utf-8')
+                format_bytes = format_str.encode('utf-8')
 
                 if manifest_data is None:
                     self._reader = _lib.c2pa_reader_from_stream(
-                        self._format_str, self._own_stream._stream)
+                        format_bytes, self._own_stream._stream)
                 else:
                     if not isinstance(manifest_data, bytes):
                         raise TypeError(
@@ -1313,7 +1437,7 @@ class Reader:
                         manifest_data)
                     self._reader = (
                         _lib.c2pa_reader_from_manifest_data_and_stream(
-                            self._format_str,
+                            format_bytes,
                             self._own_stream._stream,
                             manifest_array,
                             len(manifest_data),
@@ -1333,19 +1457,19 @@ class Reader:
                         )
                     )
 
-                self._file_like_stream = file
+                self._backing_file = file
             except Exception as e:
                 if self._own_stream:
                     self._own_stream.close()
-                if hasattr(self, '_file_like_stream'):
-                    self._file_like_stream.close()
+                if hasattr(self, '_backing_file') and self._backing_file:
+                    self._backing_file.close()
                 raise C2paError.Io(
                     Reader._ERROR_MESSAGES['io_error'].format(
                         str(e)))
         else:
             # format_or_path is a format string
             format_str = str(format_or_path)
-            if format_str not in Reader.get_supported_mime_types():
+            if format_str.lower() not in Reader.get_supported_mime_types():
                 raise C2paError.NotSupported(
                     f"Reader does not support {format_str}")
 
@@ -1386,11 +1510,85 @@ class Reader:
                     )
 
     def __enter__(self):
+        self._ensure_valid_state()
+
+        if not self._reader:
+            raise C2paError("Invalid Reader when entering context")
+
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
+    def __del__(self):
+        """Ensure resources are cleaned up if close() wasn't called.
+
+        This destructor handles cleanup without causing double frees.
+        It only cleans up if the object hasn't been explicitly closed.
+        """
+        self._cleanup_resources()
+
+    def _ensure_valid_state(self):
+        """Ensure the reader is in a valid state for operations.
+
+        Raises:
+            C2paError: If the reader is closed or invalid
+        """
+        if self._closed:
+            raise C2paError(Reader._ERROR_MESSAGES['closed_error'])
+        if not self._reader:
+            raise C2paError(Reader._ERROR_MESSAGES['closed_error'])
+
+    def _cleanup_resources(self):
+        """Internal cleanup method that releases native resources.
+
+        This method handles the actual cleanup logic and can be called
+        from both close() and __del__ without causing double frees.
+        """
+        try:
+            # Only cleanup if not already closed and we have a valid reader
+            if hasattr(self, '_closed') and not self._closed:
+                self._closed = True
+
+                # Clean up reader
+                if hasattr(self, '_reader') and self._reader:
+                    try:
+                        _lib.c2pa_reader_free(self._reader)
+                    except Exception:
+                        # Cleanup failure doesn't raise exceptions
+                        logger.error(
+                            "Failed to free native Reader resources"
+                        )
+                        pass
+                    finally:
+                        self._reader = None
+
+                # Clean up stream
+                if hasattr(self, '_own_stream') and self._own_stream:
+                    try:
+                        self._own_stream.close()
+                    except Exception:
+                        # Cleanup failure doesn't raise exceptions
+                        logger.error("Failed to close Reader stream")
+                        pass
+                    finally:
+                        self._own_stream = None
+
+                # Clean up backing file (if needed)
+                if self._backing_file:
+                    try:
+                        self._backing_file.close()
+                    except Exception:
+                        # Cleanup failure doesn't raise exceptions
+                        logger.warning("Failed to close Reader backing file")
+                        pass
+                    finally:
+                        self._backing_file = None
+
+        except Exception:
+            # Ensure we don't raise exceptions during cleanup
+            pass
+
     def close(self):
         """Release the reader resources.
 
@@ -1399,55 +1597,17 @@ class Reader:
         Errors during cleanup are logged but not raised to ensure cleanup.
         Multiple calls to close() are handled gracefully.
         """
-
-        # Track if we've already cleaned up
-        if not hasattr(self, '_closed'):
-            self._closed = False
-
         if self._closed:
             return
 
         try:
-            # Clean up reader
-            if hasattr(self, '_reader') and self._reader:
-                try:
-                    _lib.c2pa_reader_free(self._reader)
-                except Exception as e:
-                    print(
-                        Reader._ERROR_MESSAGES['reader_cleanup_error'].format(
-                            str(e)), file=sys.stderr)
-                finally:
-                    self._reader = None
-
-            # Clean up stream
-            if hasattr(self, '_own_stream') and self._own_stream:
-                try:
-                    self._own_stream.close()
-                except Exception as e:
-                    print(
-                        Reader._ERROR_MESSAGES['stream_error'].format(
-                            str(e)), file=sys.stderr)
-                finally:
-                    self._own_stream = None
-
-            # Clean up file
-            if hasattr(self, '_file_like_stream'):
-                try:
-                    self._file_like_stream.close()
-                except Exception as e:
-                    print(
-                        Reader._ERROR_MESSAGES['file_error'].format(
-                            str(e)), file=sys.stderr)
-                finally:
-                    self._file_like_stream = None
-
-            # Clear any stored strings
-            if hasattr(self, '_strings'):
-                self._strings.clear()
+            # Use the internal cleanup method
+            self._cleanup_resources()
         except Exception as e:
-            print(
+            # Log any unexpected errors during close
+            logger.error(
                 Reader._ERROR_MESSAGES['cleanup_error'].format(
-                    str(e)), file=sys.stderr)
+                    str(e)))
         finally:
             self._closed = True
 
@@ -1461,8 +1621,8 @@ class Reader:
             C2paError: If there was an error getting the JSON
         """
 
-        if not self._reader:
-            raise C2paError("Reader is closed")
+        self._ensure_valid_state()
+
         result = _lib.c2pa_reader_json(self._reader)
 
         if result is None:
@@ -1486,13 +1646,12 @@ class Reader:
         Raises:
             C2paError: If there was an error writing the resource to stream
         """
-        if not self._reader:
-            raise C2paError("Reader is closed")
+        self._ensure_valid_state()
 
-        self._uri_str = uri.encode('utf-8')
+        uri_str = uri.encode('utf-8')
         with Stream(stream) as stream_obj:
             result = _lib.c2pa_reader_resource_to_stream(
-                self._reader, self._uri_str, stream_obj._stream)
+                self._reader, uri_str, stream_obj._stream)
 
             if result < 0:
                 error = _parse_operation_result_for_error(_lib.c2pa_error())
@@ -1526,7 +1685,17 @@ class Signer:
 
         Note: This constructor is not meant to be called directly.
         Use from_info() or from_callback() instead.
+
+        Args:
+            signer_ptr: Pointer to the native C2PA signer
+
+        Raises:
+            C2paError: If the signer pointer is invalid
         """
+        # Validate pointer before assignment
+        if not signer_ptr:
+            raise C2paError("Invalid signer pointer: pointer is null")
+
         self._signer = signer_ptr
         self._closed = False
 
@@ -1652,9 +1821,9 @@ class Signer:
                 # Native code expects the signed len to be returned, we oblige
                 return actual_len
             except Exception as e:
-                print(
+                logger.error(
                     cls._ERROR_MESSAGES['callback_error'].format(
-                        str(e)), file=sys.stderr)
+                        str(e)))
                 # Error: exception raised, invalid so return -1,
                 # native code will handle the error when seeing -1
                 return -1
@@ -1701,40 +1870,85 @@ class Signer:
 
     def __enter__(self):
         """Context manager entry."""
-        if self._closed:
-            raise C2paError(Signer._ERROR_MESSAGES['closed_error'])
+        self._ensure_valid_state()
+
+        if not self._signer:
+            raise C2paError("Invalid signer pointer: pointer is null")
+
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit."""
         self.close()
 
+    def _cleanup_resources(self):
+        """Internal cleanup method that releases native resources.
+
+        This method handles the actual cleanup logic and can be called
+        from both close() and __del__ without causing double frees.
+        """
+        try:
+            if not self._closed and self._signer:
+                self._closed = True
+
+                try:
+                    _lib.c2pa_signer_free(self._signer)
+                except Exception:
+                    # Log cleanup errors but don't raise exceptions
+                    logger.error("Failed to free native Signer resources")
+                finally:
+                    self._signer = None
+
+                # Clean up callback reference
+                if self._callback_cb:
+                    self._callback_cb = None
+
+        except Exception:
+            # Ensure we don't raise exceptions during cleanup
+            pass
+
+    def _ensure_valid_state(self):
+        """Ensure the signer is in a valid state for operations.
+
+        Raises:
+            C2paError: If the signer is closed or invalid
+        """
+        if self._closed:
+            raise C2paError(Signer._ERROR_MESSAGES['closed_error'])
+        if not self._signer:
+            raise C2paError(Signer._ERROR_MESSAGES['closed_error'])
+
     def close(self):
         """Release the signer resources.
 
         This method ensures all resources are properly cleaned up,
         even if errors occur during cleanup.
-        Errors during cleanup are logged but not raised to ensure cleanup.
-        Multiple calls to close() are handled gracefully.
+
+        Note:
+            Multiple calls to close() are handled gracefully.
+            Errors during cleanup are logged but not raised
+            to ensure cleanup.
         """
         if self._closed:
             return
 
         try:
-            if self._signer:
-                try:
-                    _lib.c2pa_signer_free(self._signer)
-                except Exception as e:
-                    print(
-                        Signer._ERROR_MESSAGES['signer_cleanup'].format(
-                            str(e)), file=sys.stderr)
-                finally:
-                    self._signer = None
+            # Validate pointer before cleanup if it exists
+            if self._signer and self._signer != 0:
+                # Use the internal cleanup method
+                self._cleanup_resources()
+            else:
+                # Make sure to release the callback
+                if self._callback_cb:
+                    self._callback_cb = None
+
         except Exception as e:
-            print(
+            # Log any unexpected errors during close
+            logger.error(
                 Signer._ERROR_MESSAGES['cleanup_error'].format(
-                    str(e)), file=sys.stderr)
+                    str(e)))
         finally:
+            # Always mark as closed, regardless of cleanup success
             self._closed = True
 
     def reserve_size(self) -> int:
@@ -1746,8 +1960,7 @@ class Signer:
         Raises:
             C2paError: If there was an error getting the size
         """
-        if self._closed or not self._signer:
-            raise C2paError(Signer._ERROR_MESSAGES['closed_error'])
+        self._ensure_valid_state()
 
         result = _lib.c2pa_signer_reserve_size(self._signer)
 
@@ -1793,22 +2006,65 @@ class Builder:
 
     @classmethod
     def get_supported_mime_types(cls) -> list[str]:
+        """Get the list of supported MIME types for the Builder.
+        This method retrieves supported MIME types from the native library.
+
+        Returns:
+            List of supported MIME type strings
+
+        Raises:
+            C2paError: If there was an error retrieving the MIME types
+        """
         if cls._supported_mime_types_cache is not None:
             return cls._supported_mime_types_cache
 
         count = ctypes.c_size_t()
         arr = _lib.c2pa_builder_supported_mime_types(ctypes.byref(count))
 
+        # Validate the returned array pointer
+        if not arr:
+            # If no array returned, check for errors
+            error = _parse_operation_result_for_error(_lib.c2pa_error())
+            if error:
+                raise C2paError(f"Failed to get supported MIME types: {error}")
+            # Return empty list if no error but no array
+            return []
+
+        # Validate count value
+        if count.value <= 0:
+            # Free the array even if count is invalid
+            try:
+                _lib.c2pa_free_string_array(arr, count.value)
+            except Exception:
+                pass
+            return []
+
         try:
-            # CDecode values to place them in Python managed memory
-            result = [arr[i].decode("utf-8") for i in range(count.value)]
+            result = []
+            for i in range(count.value):
+                try:
+                    # Validate each array element before accessing
+                    if arr[i] is None:
+                        continue
+
+                    mime_type = arr[i].decode("utf-8", errors='replace')
+                    if mime_type:
+                        result.append(mime_type)
+                except Exception:
+                    # Ignore decoding failures
+                    continue
         finally:
-            # Release native memory, as per API contract
-            # c2pa_builder_supported_mime_types must call
-            # c2pa_free_string_array
-            _lib.c2pa_free_string_array(arr, count.value)
+            # Always free the native memory, even if string extraction fails
+            try:
+                _lib.c2pa_free_string_array(arr, count.value)
+            except Exception:
+                # Ignore cleanup errors
+                pass
+
+        # Cache the result
+        if result:
+            cls._supported_mime_types_cache = result
 
-        cls._supported_mime_types_cache = result
         return cls._supported_mime_types_cache
 
     def __init__(self, manifest_json: Any):
@@ -1822,6 +2078,7 @@ class Builder:
             C2paError.Encoding: If manifest JSON contains invalid UTF-8 chars
             C2paError.Json: If the manifest JSON cannot be serialized
         """
+        self._closed = False
         self._builder = None
 
         if not isinstance(manifest_json, str):
@@ -1885,6 +2142,9 @@ class Builder:
         builder._builder = _lib.c2pa_builder_from_archive(stream_obj._stream)
 
         if not builder._builder:
+            # Clean up the stream object if builder creation fails
+            stream_obj.close()
+
             error = _parse_operation_result_for_error(_lib.c2pa_error())
             if error:
                 raise C2paError(error)
@@ -1892,10 +2152,48 @@ class Builder:
 
         return builder
 
+    def _ensure_valid_state(self):
+        """Ensure the builder is in a valid state for operations.
+
+        Raises:
+            C2paError: If the builder is closed or invalid
+        """
+        if self._closed:
+            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
+        if not self._builder:
+            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
+
+    def _cleanup_resources(self):
+        """Internal cleanup method that releases native resources.
+
+        This method handles the actual cleanup logic and can be called
+        from both close() and __del__ without causing double frees.
+        """
+        try:
+            # Only cleanup if not already closed and we have a valid builder
+            if hasattr(self, '_closed') and not self._closed:
+                self._closed = True
+
+                if hasattr(
+                        self,
+                        '_builder') and self._builder and self._builder != 0:
+                    try:
+                        _lib.c2pa_builder_free(self._builder)
+                    except Exception:
+                        # Log cleanup errors but don't raise exceptions
+                        logger.error(
+                            "Failed to release native Builder resources"
+                        )
+                        pass
+                    finally:
+                        self._builder = None
+        except Exception:
+            # Ensure we don't raise exceptions during cleanup
+            pass
+
     def __del__(self):
         """Ensure resources are cleaned up if close() wasn't called."""
-        if hasattr(self, '_closed'):
-            self.close()
+        self._cleanup_resources()
 
     def close(self):
         """Release the builder resources.
@@ -1905,32 +2203,26 @@ class Builder:
         Errors during cleanup are logged but not raised to ensure cleanup.
         Multiple calls to close() are handled gracefully.
         """
-        # Track if we've already cleaned up
-        if not hasattr(self, '_closed'):
-            self._closed = False
-
         if self._closed:
             return
 
         try:
-            # Clean up builder
-            if hasattr(self, '_builder') and self._builder:
-                try:
-                    _lib.c2pa_builder_free(self._builder)
-                except Exception as e:
-                    print(
-                        Builder._ERROR_MESSAGES['builder_cleanup'].format(
-                            str(e)), file=sys.stderr)
-                finally:
-                    self._builder = None
+            # Use the internal cleanup method
+            self._cleanup_resources()
         except Exception as e:
-            print(
+            # Log any unexpected errors during close
+            logger.error(
                 Builder._ERROR_MESSAGES['cleanup_error'].format(
-                    str(e)), file=sys.stderr)
+                    str(e)))
         finally:
             self._closed = True
 
     def __enter__(self):
+        self._ensure_valid_state()
+
+        if not self._builder:
+            raise C2paError("Invalid Builder when entering context")
+
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -1943,9 +2235,7 @@ class Builder:
         into the asset when signing.
         This is useful when creating cloud or sidecar manifests.
         """
-        if not self._builder:
-            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
-
+        self._ensure_valid_state()
         _lib.c2pa_builder_set_no_embed(self._builder)
 
     def set_remote_url(self, remote_url: str):
@@ -1960,8 +2250,7 @@ class Builder:
         Raises:
             C2paError: If there was an error setting the remote URL
         """
-        if not self._builder:
-            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
+        self._ensure_valid_state()
 
         url_str = remote_url.encode('utf-8')
         result = _lib.c2pa_builder_set_remote_url(self._builder, url_str)
@@ -1984,8 +2273,7 @@ class Builder:
         Raises:
             C2paError: If there was an error adding the resource
         """
-        if not self._builder:
-            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
+        self._ensure_valid_state()
 
         uri_str = uri.encode('utf-8')
         with Stream(stream) as stream_obj:
@@ -2167,7 +2455,11 @@ class Builder:
         if not self._builder:
             raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
 
-        if format not in Builder.get_supported_mime_types():
+        # Validate signer pointer before use
+        if not signer or not hasattr(signer, '_signer') or not signer._signer:
+            raise C2paError("Invalid or closed signer")
+
+        if format.lower() not in Builder.get_supported_mime_types():
             raise C2paError.NotSupported(
                 f"Builder does not support {format}")
 
@@ -2175,14 +2467,18 @@ class Builder:
         manifest_bytes_ptr = ctypes.POINTER(ctypes.c_ubyte)()
 
         # c2pa_builder_sign uses streams
-        result = _lib.c2pa_builder_sign(
-            self._builder,
-            format_str,
-            source_stream._stream,
-            dest_stream._stream,
-            signer._signer,
-            ctypes.byref(manifest_bytes_ptr)
-        )
+        try:
+            result = _lib.c2pa_builder_sign(
+                self._builder,
+                format_str,
+                source_stream._stream,
+                dest_stream._stream,
+                signer._signer,
+                ctypes.byref(manifest_bytes_ptr)
+            )
+        except Exception as e:
+            # Handle errors during the C function call
+            raise C2paError(f"Error calling c2pa_builder_sign: {str(e)}")
 
         if result < 0:
             error = _parse_operation_result_for_error(_lib.c2pa_error())
@@ -2199,8 +2495,6 @@ class Builder:
                 ctypes.memmove(temp_buffer, manifest_bytes_ptr, result)
                 manifest_bytes = bytes(temp_buffer)
             except Exception:
-                # If there's any error accessing the memory, just return
-                # empty bytes
                 manifest_bytes = b""
             finally:
                 # Always free the C-allocated memory,
@@ -2208,7 +2502,9 @@ class Builder:
                 try:
                     _lib.c2pa_manifest_bytes_free(manifest_bytes_ptr)
                 except Exception:
-                    # Ignore errors during cleanup
+                    logger.error(
+                        "Failed to release native manifest bytes memory"
+                    )
                     pass
 
         return manifest_bytes
@@ -2269,7 +2565,9 @@ class Builder:
         """Sign a file and write the signed data to an output file.
 
         Args:
-            source_path: Path to the source file
+            source_path: Path to the source file. We will attempt
+              to guess the mimetype of the source file based on
+              the extension.
             dest_path: Path to write the signed file to
             signer: The signer to use
 
@@ -2280,10 +2578,7 @@ class Builder:
             C2paError: If there was an error during signing
         """
         # Get the MIME type from the file extension
-        mime_type = mimetypes.guess_type(str(source_path))[0]
-        if not mime_type:
-            raise C2paError.NotSupported(
-                f"Could not determine MIME type for file: {source_path}")
+        mime_type = _get_mime_type_from_path(source_path)
 
         try:
             # Open source file and destination file, then use the sign method

{c2pa_python-0.16.0 → c2pa_python-0.18.0}/src/c2pa/lib.py

@@ -16,8 +16,9 @@ from enum import Enum
 # Debug flag for library loading
 DEBUG_LIBRARY_LOADING = False
 
-# Create a module-specific logger with NullHandler to avoid interfering with global configuration
-logger = logging.getLogger("c2pa")
+# Create a module-specific logger with NullHandler
+# to avoid interfering with global configuration
+logger = logging.getLogger("c2pa.loader")
 logger.addHandler(logging.NullHandler())
 
 
@@ -107,8 +108,7 @@ def _load_single_library(lib_name: str,
         The loaded library or None if loading failed
     """
     if DEBUG_LIBRARY_LOADING:  # pragma: no cover
-        logger.info(
-            f"Searching for library '{lib_name}' in paths: {[str(p) for p in search_paths]}")
+        logger.info(f"Searching for library '{lib_name}' in paths: {[str(p) for p in search_paths]}")
     current_arch = _get_architecture()
     if DEBUG_LIBRARY_LOADING:  # pragma: no cover
         logger.info(f"Current architecture: {current_arch}")
@@ -125,12 +125,10 @@ def _load_single_library(lib_name: str,
             except Exception as e:
                 error_msg = str(e)
                 if "incompatible architecture" in error_msg:
-                    logger.error(
-                        f"Architecture mismatch: Library at {lib_path} is not compatible with current architecture {current_arch}")
+                    logger.error(f"Architecture mismatch: Library at {lib_path} is not compatible with current architecture {current_arch}")
                     logger.error(f"Error details: {error_msg}")
                 else:
-                    logger.error(
-                        f"Failed to load library from {lib_path}: {e}")
+                    logger.error(f"Failed to load library from {lib_path}: {e}")
         else:
             logger.debug(f"Library not found at: {lib_path}")
     return None
@@ -216,16 +214,14 @@ def dynamically_load_library(
     env_lib_name = os.environ.get("C2PA_LIBRARY_NAME")
     if env_lib_name:
         if DEBUG_LIBRARY_LOADING:  # pragma: no cover
-            logger.info(
-                f"Using library name from env var C2PA_LIBRARY_NAME: {env_lib_name}")
+            logger.info(f"Using library name from env var C2PA_LIBRARY_NAME: {env_lib_name}")
         try:
             possible_paths = _get_possible_search_paths()
             lib = _load_single_library(env_lib_name, possible_paths)
             if lib:
                 return lib
             else:
-                logger.error(
-                    f"Could not find library {env_lib_name} in any of the search paths")
+                logger.error(f"Could not find library {env_lib_name} in any of the search paths")
                 # Continue with normal loading if environment variable library
                 # name fails
         except Exception as e:
@@ -241,12 +237,9 @@ def dynamically_load_library(
         if not lib:
             platform_id = get_platform_identifier()
             current_arch = _get_architecture()
-            logger.error(
-                f"Could not find {lib_name} in any of the search paths: {[str(p) for p in possible_paths]}")
-            logger.error(
-                f"Platform: {platform_id}, Architecture: {current_arch}")
-            raise RuntimeError(
-                f"Could not find {lib_name} in any of the search paths (Platform: {platform_id}, Architecture: {current_arch})")
+            logger.error(f"Could not find {lib_name} in any of the search paths: {[str(p) for p in possible_paths]}")
+            logger.error(f"Platform: {platform_id}, Architecture: {current_arch}")
+            raise RuntimeError(f"Could not find {lib_name} in any of the search paths (Platform: {platform_id}, Architecture: {current_arch})")
         return lib
 
     # Default path (no library name provided in the environment)

{c2pa_python-0.16.0 → c2pa_python-0.18.0/src/c2pa_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.16.0
+Version: 0.18.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.16.0 → c2pa_python-0.18.0}/tests/test_unit_tests.py

@@ -126,9 +126,6 @@ class TestReader(unittest.TestCase):
     def test_reader_close_cleanup(self):
         with open(self.testPath, "rb") as file:
             reader = Reader("image/jpeg", file)
-            # Store references to internal objects
-            reader_ref = reader._reader
-            stream_ref = reader._own_stream
             # Close the reader
             reader.close()
             # Verify all resources are cleaned up
@@ -144,6 +141,32 @@ class TestReader(unittest.TestCase):
         with self.assertRaises(Error):
             reader.resource_to_stream("", io.BytesIO(bytearray()))
 
+    def test_read_dng_from_stream(self):
+        test_path = os.path.join(self.data_dir, "C.dng")
+        with open(test_path, "rb") as file:
+            file_content = file.read()
+
+        with Reader("dng", io.BytesIO(file_content)) as reader:
+            # Just run and verify there is no crash
+            json.loads(reader.json())
+
+    def test_read_dng_upper_case_from_stream(self):
+        test_path = os.path.join(self.data_dir, "C.dng")
+        with open(test_path, "rb") as file:
+            file_content = file.read()
+
+        with Reader("DNG", io.BytesIO(file_content)) as reader:
+            # Just run and verify there is no crash
+            json.loads(reader.json())
+
+    def test_read_dng_file_from_path(self):
+        test_path = os.path.join(self.data_dir, "C.dng")
+
+        # Create reader with the file content
+        with Reader(test_path) as reader:
+            # Just run and verify there is no crash
+            json.loads(reader.json())
+
     def test_read_all_files(self):
         """Test reading C2PA metadata from all files in the fixtures/files-for-reading-tests directory"""
         reading_dir = os.path.join(self.data_dir, "files-for-reading-tests")