fix: Refactor once more with overload

Author: tmathern

src/c2pa/c2pa.py

@@ -597,13 +597,10 @@ def sign_file(
     source_path: Union[str, Path],
     dest_path: Union[str, Path],
     manifest: str,
-    signer_info: C2paSignerInfo
-) -> str:
+    signer_info: C2paSignerInfo,
+    return_manifest_as_bytes: bool = False
+) -> Union[str, bytes]:
     """Sign a file with a C2PA manifest using signer info.
-
-    .. deprecated:: 0.10.0
-        This function is deprecated and will be removed in a future version.
-        Please use the Builder class for signing and the Reader class for reading signed data instead.
     """
     ...
 
@@ -612,22 +609,20 @@ def sign_file(
     source_path: Union[str, Path],
     dest_path: Union[str, Path],
     manifest: str,
-    signer: 'Signer'
-) -> str:
+    signer: 'Signer',
+    return_manifest_as_bytes: bool = False
+) -> Union[str, bytes]:
     """Sign a file with a C2PA manifest using a signer.
-
-    .. deprecated:: 0.10.0
-        This function is deprecated and will be removed in a future version.
-        Please use the Builder class for signing and the Reader class for reading signed data instead.
     """
     ...
 
 def sign_file(
     source_path: Union[str, Path],
     dest_path: Union[str, Path],
     manifest: str,
-    signer_or_info: Union[C2paSignerInfo, 'Signer']
-) -> str:
+    signer_or_info: Union[C2paSignerInfo, 'Signer'],
+    return_manifest_as_bytes: bool = False
+) -> Union[str, bytes]:
     """Sign a file with a C2PA manifest.
     For now, this function is left here to provide a backwards-compatible API.
 
@@ -636,9 +631,10 @@ def sign_file(
         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
+        return_manifest_as_bytes: If True, return manifest bytes instead of JSON string
 
     Returns:
-        The signed manifest as a JSON string
+        The signed manifest as a JSON string or bytes, depending on return_manifest_as_bytes
 
     Raises:
         C2paError: If there was an error signing the file
@@ -666,17 +662,28 @@ def sign_file(
                 raise C2paError.NotSupported(
                     f"Could not determine MIME type for file: {source_path}")
 
-            # Sign the file using the builder
-            builder.sign(
-                signer=signer,
-                format=mime_type,
-                source=source_file,
-                dest=dest_file
-            )
+            if return_manifest_as_bytes:
+                # Convert Python streams to Stream objects for internal signing
+                source_stream = Stream(source_file)
+                dest_stream = Stream(dest_file)
+
+                # Use the builder's internal signing logic to get manifest bytes
+                result, manifest_bytes = builder._sign_internal(
+                    signer, mime_type, source_stream, dest_stream)
+
+                return manifest_bytes
+            else:
+                # Sign the file using the builder
+                builder.sign(
+                    signer=signer,
+                    format=mime_type,
+                    source=source_file,
+                    dest=dest_file
+                )
 
-            # Read the signed manifest from the destination file
-            with Reader(dest_path) as reader:
-                return reader.json()
+                # Read the signed manifest from the destination file
+                with Reader(dest_path) as reader:
+                    return reader.json()
 
     except Exception as e:
         # Clean up destination file if it exists and there was an error

tests/test_unit_tests.py

@@ -936,12 +936,13 @@ def sign_callback(data: bytes) -> bytes:
                 tsa_url="http://timestamp.digicert.com"
             )
 
-            # Use the overloaded sign_file function with a Signer object
+            # Test with return_manifest_as_bytes=False (default) - should return JSON string
             result_json = sign_file(
                 self.testPath,
                 output_path,
                 self.manifestDefinition,
-                signer
+                signer,
+                False
             )
 
             # Verify the output file was created
@@ -956,6 +957,23 @@ def sign_callback(data: bytes) -> bytes:
             self.assertIn("manifests", manifest_data)
             self.assertIn("active_manifest", manifest_data)
 
+            # Test with return_manifest_as_bytes=True - should return bytes
+            output_path_bytes = os.path.join(temp_dir, "signed_output_callback_bytes.jpg")
+            result_bytes = sign_file(
+                self.testPath,
+                output_path_bytes,
+                self.manifestDefinition,
+                signer,
+                True
+            )
+
+            # Verify the output file was created
+            self.assertTrue(os.path.exists(output_path_bytes))
+
+            # Verify the result is bytes (not JSON string)
+            self.assertIsInstance(result_bytes, bytes)
+            self.assertGreater(len(result_bytes), 0)
+
             # Read the signed file and verify the manifest contains expected content
             with open(output_path, "rb") as file:
                 reader = Reader("image/jpeg", file)
@@ -989,35 +1007,63 @@ def test_sign_file_overloads(self):
                 ta_url=b"http://timestamp.digicert.com"
             )
 
-            # Test with C2paSignerInfo parameter
+            # Test with C2paSignerInfo parameter - JSON return
             result_1 = sign_file(
                 self.testPath,
                 output_path_1,
                 self.manifestDefinition,
-                signer_info
+                signer_info,
+                False
             )
 
             self.assertIsInstance(result_1, str)
             self.assertTrue(os.path.exists(output_path_1))
 
+            # Test with C2paSignerInfo parameter - bytes return
+            output_path_1_bytes = os.path.join(temp_dir, "signed_output_1_bytes.jpg")
+            result_1_bytes = sign_file(
+                self.testPath,
+                output_path_1_bytes,
+                self.manifestDefinition,
+                signer_info,
+                True
+            )
+            
+            self.assertIsInstance(result_1_bytes, bytes)
+            self.assertTrue(os.path.exists(output_path_1_bytes))
+
             # Test with Signer object
             output_path_2 = os.path.join(temp_dir, "signed_output_2.jpg")
 
             # Create a signer from the signer info
             signer = Signer.from_info(signer_info)
 
-            # Test with Signer parameter
+            # Test with Signer parameter - JSON return
             result_2 = sign_file(
                 self.testPath,
                 output_path_2,
                 self.manifestDefinition,
-                signer
+                signer,
+                False
             )
 
             self.assertIsInstance(result_2, str)
             self.assertTrue(os.path.exists(output_path_2))
+
+            # Test with Signer parameter - bytes return
+            output_path_2_bytes = os.path.join(temp_dir, "signed_output_2_bytes.jpg")
+            result_2_bytes = sign_file(
+                self.testPath,
+                output_path_2_bytes,
+                self.manifestDefinition,
+                signer,
+                True
+            )
 
-            # Both results should be similar (same manifest structure)
+            self.assertIsInstance(result_2_bytes, bytes)
+            self.assertTrue(os.path.exists(output_path_2_bytes))
+            
+            # Both JSON results should be similar (same manifest structure)
             manifest_1 = json.loads(result_1)
             manifest_2 = json.loads(result_2)
 
@@ -1026,6 +1072,10 @@ def test_sign_file_overloads(self):
             self.assertIn("active_manifest", manifest_1)
             self.assertIn("active_manifest", manifest_2)
 
+            # Both bytes results should be non-empty
+            self.assertGreater(len(result_1_bytes), 0)
+            self.assertGreater(len(result_2_bytes), 0)
+
         finally:
             # Clean up the temporary directory
             shutil.rmtree(temp_dir)