c2pa-python 0.12.0__tar.gz → 0.12.1__tar.gz

{c2pa_python-0.12.0/src/c2pa_python.egg-info → c2pa_python-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c2pa-python
-Version: 0.12.0
+Version: 0.12.1
 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.12.0 → c2pa_python-0.12.1}/pyproject.toml

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

@@ -123,6 +123,19 @@ class C2paSigningAlg(enum.IntEnum):
     ED25519 = 6
 
 
+# Mapping from C2paSigningAlg enum to string representation,
+# as the enum value currently maps by default to an integer value.
+_ALG_TO_STRING_BYTES_MAPPING = {
+    C2paSigningAlg.ES256: b"es256",
+    C2paSigningAlg.ES384: b"es384",
+    C2paSigningAlg.ES512: b"es512",
+    C2paSigningAlg.PS256: b"ps256",
+    C2paSigningAlg.PS384: b"ps384",
+    C2paSigningAlg.PS512: b"ps512",
+    C2paSigningAlg.ED25519: b"ed25519",
+}
+
+
 # Define callback types
 ReadCallback = ctypes.CFUNCTYPE(
     ctypes.c_ssize_t,
@@ -205,6 +218,45 @@ class C2paSignerInfo(ctypes.Structure):
         ("ta_url", ctypes.c_char_p),
     ]
 
+    def __init__(self, alg, sign_cert, private_key, ta_url):
+        """Initialize C2paSignerInfo with optional parameters.
+
+        Args:
+            alg: The signing algorithm, either as a C2paSigningAlg enum or string or bytes
+            (will be converted accordingly to bytes for native library use)
+            sign_cert: The signing certificate as a string
+            private_key: The private key as a string
+            ta_url: The timestamp authority URL as bytes
+        """
+        # Handle alg parameter: can be C2paSigningAlg enum or string (or bytes), convert as needed
+        if isinstance(alg, C2paSigningAlg):
+            # Convert enum to string representation
+            alg_str = _ALG_TO_STRING_BYTES_MAPPING.get(alg)
+            if alg_str is None:
+                raise ValueError(f"Unsupported signing algorithm: {alg}")
+            alg = alg_str
+        elif isinstance(alg, str):
+            # String to bytes, as requested by native lib
+            alg = alg.encode('utf-8')
+        elif isinstance(alg, bytes):
+            # In bytes already
+            pass
+        else:
+            raise TypeError(f"alg must be C2paSigningAlg enum, string, or bytes, got {type(alg)}")
+
+        # Handle ta_url parameter: allow string or bytes, convert string to bytes as needed
+        if isinstance(ta_url, str):
+            # String to bytes, as requested by native lib
+            ta_url = ta_url.encode('utf-8')
+        elif isinstance(ta_url, bytes):
+            # In bytes already
+            pass
+        else:
+            raise TypeError(f"ta_url must be string or bytes, got {type(ta_url)}")
+
+        # Call parent constructor with processed values
+        super().__init__(alg, sign_cert, private_key, ta_url)
+
 
 class C2paReader(ctypes.Structure):
     """Opaque structure for reader context."""

{c2pa_python-0.12.0 → c2pa_python-0.12.1}/src/c2pa/lib.py

@@ -16,13 +16,9 @@ from enum import Enum
 # Debug flag for library loading
 DEBUG_LIBRARY_LOADING = False
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    force=True  # Force configuration even if already configured
-)
-logger = logging.getLogger(__name__)
+# Create a module-specific logger with NullHandler to avoid interfering with global configuration
+logger = logging.getLogger("c2pa")
+logger.addHandler(logging.NullHandler())
 
 
 class CPUArchitecture(Enum):

{c2pa_python-0.12.0 → c2pa_python-0.12.1/src/c2pa_python.egg-info}/PKG-INFO

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

@@ -39,7 +39,7 @@ ALTERNATIVE_INGREDIENT_TEST_FILE = os.path.join(FIXTURES_DIR, "cloud.jpg")
 
 class TestC2paSdk(unittest.TestCase):
     def test_sdk_version(self):
-        self.assertIn("0.55.0", sdk_version())
+        self.assertIn("0.58.0", sdk_version())
 
 
 class TestReader(unittest.TestCase):
@@ -95,6 +95,13 @@ class TestReader(unittest.TestCase):
             with self.assertRaises(Error):
                 reader.json()
 
+    def test_reader_streams_with_nested(self):
+        with open(self.testPath, "rb") as file:
+            with Reader("image/jpeg", file) as reader:
+                manifest_store = json.loads(reader.json())
+                title = manifest_store["manifests"][manifest_store["active_manifest"]]["title"]
+                self.assertEqual(title, DEFAULT_TEST_FILE_NAME)
+
     def test_reader_close_cleanup(self):
         """Test that close properly cleans up all resources."""
         with open(self.testPath, "rb") as file:
@@ -292,6 +299,33 @@ class TestBuilder(unittest.TestCase):
             ]
         }
 
+        # Define a V2 manifest as a dictionary
+        self.manifestDefinitionV2 = {
+            "claim_generator": "python_test",
+            "claim_generator_info": [{
+                "name": "python_test",
+                "version": "0.0.1",
+            }],
+            "claim_version": 2,
+            "format": "image/jpeg",
+            "title": "Python Test Image V2",
+            "ingredients": [],
+            "assertions": [
+                {
+                    "label": "c2pa.actions",
+                    "data": {
+                        "actions": [
+                            {
+                                "action": "c2pa.created",
+                                "parameters": {
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+
         # Define an example ES256 callback signer
         self.callback_signer_alg = "Es256"
         def callback_signer_es256(data: bytes) -> bytes:
@@ -991,6 +1025,57 @@ class TestBuilder(unittest.TestCase):
         finally:
             shutil.rmtree(temp_dir)
 
+    def test_builder_sign_file_callback_signer_from_callback_V2(self):
+        """Test signing a file using the sign_file method with Signer.from_callback."""
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+
+            output_path = os.path.join(temp_dir, "signed_output_from_callback.jpg")
+
+            # Will use the sign_file method
+            builder = Builder(self.manifestDefinitionV2)
+
+            # Create signer with callback using Signer.from_callback
+            signer = Signer.from_callback(
+                callback=self.callback_signer_es256,
+                alg=SigningAlg.ES256,
+                certs=self.certs.decode('utf-8'),
+                tsa_url="http://timestamp.digicert.com"
+            )
+
+            manifest_bytes = builder.sign_file(
+                source_path=self.testPath,
+                dest_path=output_path,
+                signer=signer
+            )
+
+            # Verify the output file was created
+            self.assertTrue(os.path.exists(output_path))
+
+            # Verify results
+            self.assertIsInstance(manifest_bytes, bytes)
+            self.assertGreater(len(manifest_bytes), 0)
+
+            # Read the signed file and verify the manifest
+            with open(output_path, "rb") as file, Reader("image/jpeg", file) as reader:
+                json_data = reader.json()
+                self.assertIn("Python Test", json_data)
+                self.assertNotIn("validation_status", json_data)
+
+                # Parse the JSON and verify the signature algorithm
+                manifest_data = json.loads(json_data)
+                active_manifest_id = manifest_data["active_manifest"]
+                active_manifest = manifest_data["manifests"][active_manifest_id]
+
+                # Verify the signature_info contains the correct algorithm
+                self.assertIn("signature_info", active_manifest)
+                signature_info = active_manifest["signature_info"]
+                self.assertEqual(signature_info["alg"], self.callback_signer_alg)
+
+        finally:
+            shutil.rmtree(temp_dir)
+
     def test_sign_file_using_callback_signer_overloads(self):
         """Test signing a file using the sign_file function with a Signer object."""
         # Create a temporary directory for the test
@@ -1191,6 +1276,30 @@ class TestBuilder(unittest.TestCase):
         finally:
             shutil.rmtree(temp_dir)
 
+    def test_signing_manifest_v2(self):
+        """Test signing and reading a V2 manifest.
+        V2 manifests have a slightly different structure.
+        """
+        with open(self.testPath, "rb") as file:
+            # Create a builder with the V2 manifest definition using context manager
+            with Builder(self.manifestDefinitionV2) as builder:
+                output = io.BytesIO(bytearray())
+
+                # Sign as usual...
+                builder.sign(self.signer, "image/jpeg", file, output)
+
+                output.seek(0)
+
+                # Read the signed file and verify the manifest using context manager
+                with Reader("image/jpeg", output) as reader:
+                    json_data = reader.json()
+
+                    # Basic verification of the manifest
+                    self.assertIn("Python Test Image V2", json_data)
+                    self.assertNotIn("validation_status", json_data)
+
+                output.close()
+
 class TestStream(unittest.TestCase):
     def setUp(self):
         # Create a temporary file for testing
@@ -1384,7 +1493,69 @@ class TestLegacyAPI(unittest.TestCase):
         self.assertIn("manifests", file_data)
         self.assertIn(expected_manifest_id, file_data["manifests"])
 
-    def test_sign_file(self):
+    def test_sign_file_alg_as_enum(self):
+        """Test signing a file with C2PA manifest."""
+        # Set up test paths
+        temp_data_dir = os.path.join(self.data_dir, "temp_data")
+        os.makedirs(temp_data_dir, exist_ok=True)
+        output_path = os.path.join(temp_data_dir, "signed_output.jpg")
+
+        # Load test certificates and key
+        with open(os.path.join(self.data_dir, "es256_certs.pem"), "rb") as cert_file:
+            certs = cert_file.read()
+        with open(os.path.join(self.data_dir, "es256_private.key"), "rb") as key_file:
+            key = key_file.read()
+
+        # Create signer info
+        signer_info = C2paSignerInfo(
+            alg=SigningAlg.ES256,
+            sign_cert=certs,
+            private_key=key,
+            ta_url=b"http://timestamp.digicert.com"
+        )
+
+        # Create a simple manifest
+        manifest = {
+            "claim_generator": "python_internals_test",
+            "claim_generator_info": [{
+                "name": "python_internals_test",
+                "version": "0.0.1",
+            }],
+            "format": "image/jpeg",
+            "title": "Python Test Signed Image",
+            "ingredients": [],
+            "assertions": [
+                {
+                    "label": "c2pa.actions",
+                    "data": {
+                        "actions": [
+                            {
+                                "action": "c2pa.opened"
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+
+        # Convert manifest to JSON string
+        manifest_json = json.dumps(manifest)
+
+        try:
+            # Sign the file
+            result_json = sign_file(
+                self.testPath,
+                output_path,
+                manifest_json,
+                signer_info
+            )
+
+        finally:
+            # Clean up
+            if os.path.exists(output_path):
+                os.remove(output_path)
+
+    def test_sign_file_alg_as_bytes(self):
         """Test signing a file with C2PA manifest."""
         # Set up test paths
         temp_data_dir = os.path.join(self.data_dir, "temp_data")