c2pa-python 0.34.0__tar.gz → 0.35.0__tar.gz

{c2pa_python-0.34.0/src/c2pa_python.egg-info → c2pa_python-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.34.0
+Version: 0.35.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.34.0 → c2pa_python-0.35.0}/pyproject.toml

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

@@ -22,7 +22,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Optional, Union, Callable, Any, overload
 import io
-from .lib import dynamically_load_library
+from .lib import dynamically_load_library, record_owner_pid, is_foreign_process
 import mimetypes
 from itertools import count
 
@@ -238,6 +238,7 @@ class ManagedResource:
         self._lifecycle_state = LifecycleState.UNINITIALIZED
         self._handle = None
         _clear_error_state()
+        record_owner_pid(self)
 
     @staticmethod
     def _free_native_ptr(ptr):
@@ -280,6 +281,8 @@ class ManagedResource:
     def _cleanup_resources(self):
         """Release native resources idempotently."""
         try:
+            if is_foreign_process(self):
+                return
             if (
                 hasattr(self, '_lifecycle_state')
                 and self._lifecycle_state != LifecycleState.CLOSED
@@ -1768,6 +1771,7 @@ class Stream:
             raise Exception("Failed to create stream: {}".format(error))
 
         self._initialized = True
+        record_owner_pid(self)
 
     def __enter__(self):
         """Context manager entry."""
@@ -1786,6 +1790,8 @@ class Stream:
         hasn't been explicitly closed.
         """
         try:
+            if is_foreign_process(self):
+                return
             # Only cleanup if not already closed and we have a valid stream
             if hasattr(self, '_closed') and not self._closed:
                 stream = self._stream
@@ -1816,6 +1822,10 @@ class Stream:
         """
         if self._closed:
             return
+        if is_foreign_process(self):
+            self._closed = True
+            self._initialized = False
+            return
 
         try:
             # Clean up stream first as it depends on callbacks

{c2pa_python-0.34.0 → c2pa_python-0.35.0}/src/c2pa/lib.py

@@ -299,3 +299,28 @@ def dynamically_load_library(
             raise RuntimeError(f"Could not find {c2pa_lib_name} in any of the search paths")
 
     return c2pa_lib
+
+
+def record_owner_pid(obj):
+    """Keep the PID that created this native-handle wrapper
+    (call from __init__ as needed).
+    """
+    obj._owner_pid = os.getpid()
+
+
+def is_foreign_process(obj):
+    """Return True when this object is being finalized in a forked child that did not
+    create it. After a multithreaded fork(), native mutexes may be held by threads
+    absent in the child -> any lock() call deadlocks. Callers must skip native frees
+    when this returns True.
+
+    Skipping the free does not cause a cumulative leak. If the child calls exec() the
+    address space is replaced entirely; if it exits, the OS reclaims all process memory.
+    Even a long-lived fork child (e.g. a multiprocessing fork-start worker) leaks at most
+    the objects inherited at fork time — a one-time, bounded amount reclaimed when the
+    child terminates. Objects the child creates itself carry the child's PID and are
+    freed normally.
+
+    Defensive default: if _owner_pid was never set, returns False (no regression)."""
+    owner = getattr(obj, '_owner_pid', None)
+    return owner is not None and owner != os.getpid()

{c2pa_python-0.34.0 → c2pa_python-0.35.0/src/c2pa_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.34.0
+Version: 0.35.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.34.0 → c2pa_python-0.35.0}/tests/test_unit_tests_threaded.py

@@ -11,6 +11,7 @@
 # specific language governing permissions and limitations under
 # each license.
 
+import ctypes
 import os
 import io
 import json
@@ -20,13 +21,172 @@ import concurrent.futures
 import time
 import asyncio
 import random
+from unittest.mock import MagicMock, patch
 
 from c2pa import Builder, C2paError as Error, Reader, C2paSigningAlg as SigningAlg, C2paSignerInfo, Signer, sdk_version  # noqa: E501
 from c2pa import Context, Settings
-from c2pa.c2pa import Stream
+from c2pa.c2pa import ManagedResource, Stream, LifecycleState
+from c2pa.lib import is_foreign_process, record_owner_pid
 
 PROJECT_PATH = os.getcwd()
 FIXTURES_FOLDER = os.path.join(os.path.dirname(__file__), "fixtures")
+
+
+class _ConcreteResource(ManagedResource):
+    """Minimal concrete subclass for testing ManagedResource cleanup."""
+
+
+def _make_resource(pid_offset):
+    """Construct a ManagedResource-like object without triggering native init.
+
+    pid_offset=1  → simulates a forked child (foreign PID)
+    pid_offset=0  → same process (normal cleanup)
+    pid_offset=None → no _owner_pid stamp (backward-compat: no protection)
+    """
+    obj = object.__new__(_ConcreteResource)
+    obj._lifecycle_state = LifecycleState.ACTIVE
+    obj._handle = ctypes.c_void_p(1)  # non-None, non-zero sentinel
+    if pid_offset is not None:
+        obj._owner_pid = os.getpid() + pid_offset
+    return obj
+
+
+def _make_stream(pid_offset):
+    """Construct a Stream-like object without triggering native init."""
+    obj = object.__new__(Stream)
+    obj._closed = False
+    obj._initialized = True
+    obj._stream = MagicMock()  # non-None stream handle
+    if pid_offset is not None:
+        obj._owner_pid = os.getpid() + pid_offset
+    return obj
+
+
+class TestManagedResourceForkGuard(unittest.TestCase):
+    """Fork-safety unit tests for ManagedResource and Stream.
+
+    Verifies that the is_foreign_process() PID guard prevents native frees
+    from running in a forked child process (where native mutexes may be held
+    by threads that no longer exist, causing deadlock before exec()).
+
+    No real fork or auth credentials are required; PID mismatch is simulated
+    by setting _owner_pid = os.getpid() + 1.
+    """
+
+    def test_foreign_pid_skips_free(self):
+        """In a forked child (pid_offset=1), no native free should run."""
+        obj = _make_resource(pid_offset=1)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj._cleanup_resources()
+        mock_lib.c2pa_free.assert_not_called()
+
+    def test_own_pid_calls_free(self):
+        """In the owning process, cleanup must call c2pa_free normally."""
+        obj = _make_resource(pid_offset=0)
+        expected_handle = obj._handle
+        with patch('c2pa.c2pa._lib'):
+            with patch.object(ManagedResource, '_free_native_ptr') as mock_free:
+                obj._cleanup_resources()
+        mock_free.assert_called_once_with(expected_handle)
+
+    def test_no_stamp_calls_free(self):
+        """No _owner_pid (backward-compat) must NOT suppress cleanup."""
+        obj = _make_resource(pid_offset=None)
+        with patch.object(ManagedResource, '_free_native_ptr') as mock_free:
+            obj._cleanup_resources()
+        mock_free.assert_called_once()
+
+    def test_foreign_pid_leaves_state_unchanged(self):
+        """Guard returns early; lifecycle state stays ACTIVE (not CLOSED)."""
+        obj = _make_resource(pid_offset=1)
+        with patch('c2pa.c2pa._lib'):
+            obj._cleanup_resources()
+        self.assertEqual(obj._lifecycle_state, LifecycleState.ACTIVE)
+
+    def test_double_cleanup_is_idempotent(self):
+        """Second call is a no-op after successful first cleanup."""
+        obj = _make_resource(pid_offset=0)
+        with patch.object(ManagedResource, '_free_native_ptr') as mock_free:
+            obj._cleanup_resources()
+            obj._cleanup_resources()
+        mock_free.assert_called_once()
+
+    def test_foreign_pid_skips_release_via_del(self):
+        obj = _make_stream(pid_offset=1)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.__del__()
+        mock_lib.c2pa_release_stream.assert_not_called()
+
+    def test_own_pid_releases_stream_via_del(self):
+        obj = _make_stream(pid_offset=0)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.__del__()
+        mock_lib.c2pa_release_stream.assert_called_once()
+
+    def test_no_stamp_releases_stream_via_del(self):
+        obj = _make_stream(pid_offset=None)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.__del__()
+        mock_lib.c2pa_release_stream.assert_called_once()
+
+    def test_already_closed_is_noop_via_del(self):
+        obj = _make_stream(pid_offset=0)
+        obj._closed = True
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.__del__()
+        mock_lib.c2pa_release_stream.assert_not_called()
+
+    def test_foreign_pid_skips_release_via_close(self):
+        obj = _make_stream(pid_offset=1)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.close()
+        mock_lib.c2pa_release_stream.assert_not_called()
+        self.assertTrue(obj._closed)
+
+    def test_own_pid_releases_stream_via_close(self):
+        obj = _make_stream(pid_offset=0)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.close()
+        mock_lib.c2pa_release_stream.assert_called_once()
+
+    def test_no_stamp_releases_stream_via_close(self):
+        obj = _make_stream(pid_offset=None)
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.close()
+        mock_lib.c2pa_release_stream.assert_called_once()
+
+    def test_already_closed_is_noop_via_close(self):
+        obj = _make_stream(pid_offset=0)
+        obj._closed = True
+        with patch('c2pa.c2pa._lib') as mock_lib:
+            obj.close()
+        mock_lib.c2pa_release_stream.assert_not_called()
+
+    def test_foreign_pid_close_marks_closed(self):
+        """close() in forked child must set _closed=True to prevent re-entry,
+        and _initialized=False so the public properties report a closed stream."""
+        obj = _make_stream(pid_offset=1)
+        with patch('c2pa.c2pa._lib'):
+            obj.close()
+        self.assertTrue(obj._closed)
+        self.assertFalse(obj._initialized)
+
+
+class TestHelpers(unittest.TestCase):
+
+    def test_record_and_detect_own_pid(self):
+        obj = MagicMock()
+        record_owner_pid(obj)
+        self.assertFalse(is_foreign_process(obj))
+
+    def test_detect_foreign_pid(self):
+        obj = MagicMock()
+        obj._owner_pid = os.getpid() + 1
+        self.assertTrue(is_foreign_process(obj))
+
+    def test_no_stamp_not_foreign(self):
+        obj = MagicMock(spec=[])  # no _owner_pid attribute
+        self.assertFalse(is_foreign_process(obj))
 DEFAULT_TEST_FILE = os.path.join(FIXTURES_FOLDER, "C.jpg")
 INGREDIENT_TEST_FILE = os.path.join(FIXTURES_FOLDER, "A.jpg")
 ALTERNATIVE_INGREDIENT_TEST_FILE = os.path.join(FIXTURES_FOLDER, "cloud.jpg")