fix: Refactor

Author: tmathern

src/c2pa/c2pa.py

@@ -1764,27 +1764,7 @@ def add_ingredient(self, ingredient_json: str, format: str, source: Any):
             C2paError: If there was an error adding the ingredient
             C2paError.Encoding: If the ingredient JSON contains invalid UTF-8 characters
         """
-        if not self._builder:
-            raise C2paError(Builder._ERROR_MESSAGES['closed_error'])
-
-        try:
-            ingredient_str = ingredient_json.encode('utf-8')
-            format_str = format.encode('utf-8')
-        except UnicodeError as e:
-            raise C2paError.Encoding(
-                Builder._ERROR_MESSAGES['encoding_error'].format(
-                    str(e)))
-
-        source_stream = Stream(source)
-        result = _lib.c2pa_builder_add_ingredient_from_stream(
-            self._builder, ingredient_str, format_str, source_stream._stream)
-
-        if result != 0:
-            error = _parse_operation_result_for_error(_lib.c2pa_error())
-            if error:
-                raise C2paError(error)
-            raise C2paError(
-                Builder._ERROR_MESSAGES['ingredient_error'].format("Unknown error"))
+        return self.add_ingredient_from_stream(ingredient_json, format, source)
 
     def add_ingredient_from_stream(
             self,

tests/test_unit_tests_threaded.py

@@ -1469,93 +1469,6 @@ async def run_async_tests():
         # Verify all readers completed
         self.assertEqual(active_readers, 0, "Not all readers completed")
 
-    def test_builder_sign_with_multiple_ingredient(self):
-        """Test Builder class operations with multiple ingredients added in parallel threads."""
-        # Test creating builder from JSON
-        builder = Builder.from_json(self.manifestDefinition)
-        assert builder._builder is not None
-
-        # Define paths for test files
-        cloud_path = os.path.join(self.data_dir, "cloud.jpg")
-
-        # Thread synchronization
-        ingredient_added = threading.Event()
-        add_errors = []
-        add_lock = threading.Lock()
-
-        def add_ingredient(ingredient_json, file_path, thread_id):
-            try:
-                with open(file_path, 'rb') as f:
-                    builder.add_ingredient(ingredient_json, "image/jpeg", f)
-                with add_lock:
-                    add_errors.append(None)  # Success case
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(f"Thread {thread_id} error: {str(e)}")
-            finally:
-                ingredient_added.set()
-
-        # Create and start two threads for parallel ingredient addition
-        thread1 = threading.Thread(
-            target=add_ingredient,
-            args=('{"title": "Test Ingredient 1"}', self.testPath3, 1)
-        )
-        thread2 = threading.Thread(
-            target=add_ingredient,
-            args=('{"title": "Test Ingredient 2"}', cloud_path, 2)
-        )
-
-        # Start both threads
-        thread1.start()
-        thread2.start()
-
-        # Wait for both threads to complete
-        thread1.join()
-        thread2.join()
-
-        # Check for errors during ingredient addition
-        if any(error for error in add_errors if error is not None):
-            self.fail(
-                "\n".join(
-                    error for error in add_errors if error is not None))
-
-        # Verify both ingredients were added successfully
-        self.assertEqual(
-            len(add_errors),
-            2,
-            "Both threads should have completed")
-
-        # Now sign the manifest with the added ingredients
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            reader = Reader("image/jpeg", output)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-
-            # Verify active manifest exists
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-
-            # Verify active manifest object exists
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-
-            # Verify ingredients array exists in active manifest
-            self.assertIn("ingredients", active_manifest)
-            self.assertIsInstance(active_manifest["ingredients"], list)
-            self.assertEqual(len(active_manifest["ingredients"]), 2)
-
-            # Verify both ingredients exist in the array (order doesn't matter)
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
-            self.assertIn("Test Ingredient 1", ingredient_titles)
-            self.assertIn("Test Ingredient 2", ingredient_titles)
-
-        builder.close()
-
     def test_builder_sign_with_multiple_ingredients_from_stream(self):
         """Test Builder class operations with multiple ingredients using streams."""
         # Test creating builder from JSON
@@ -1648,248 +1561,6 @@ def add_ingredient_from_stream(ingredient_json, file_path, thread_id):
 
         builder.close()
 
-    def test_builder_sign_with_multiple_ingredient_random(self):
-        """Test Builder class operations with 5 random ingredients added in parallel threads."""
-        # Test creating builder from JSON
-        builder = Builder.from_json(self.manifestDefinition)
-        assert builder._builder is not None
-
-        # Get list of files from files-for-reading-tests directory
-        reading_dir = os.path.join(self.data_dir, "files-for-reading-tests")
-        all_files = [
-            f for f in os.listdir(reading_dir) if os.path.isfile(
-                os.path.join(
-                    reading_dir, f))]
-
-        # Select 5 random files
-        random.seed(42)  # For reproducible testing
-        selected_files = random.sample(all_files, 5)
-
-        # Thread synchronization
-        add_errors = []
-        add_lock = threading.Lock()
-        completed_threads = 0
-        completion_lock = threading.Lock()
-
-        def add_ingredient(file_name, thread_id):
-            nonlocal completed_threads
-            try:
-                file_path = os.path.join(reading_dir, file_name)
-                ingredient_json = json.dumps({
-                    "title": f"Test Ingredient Thread {thread_id} - {file_name}"
-                })
-
-                with open(file_path, 'rb') as f:
-                    builder.add_ingredient(ingredient_json, "image/jpeg", f)
-
-                with add_lock:
-                    add_errors.append(None)  # Success case
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(
-                        f"Thread {thread_id} error with file {file_name}: {
-                            str(e)}")
-            finally:
-                with completion_lock:
-                    completed_threads += 1
-
-        # Create and start 5 threads for parallel ingredient addition
-        threads = []
-        for i, file_name in enumerate(selected_files, 1):
-            thread = threading.Thread(
-                target=add_ingredient,
-                args=(file_name, i)
-            )
-            threads.append(thread)
-            thread.start()
-
-        # Wait for all threads to complete
-        for thread in threads:
-            thread.join()
-
-        # Check for errors during ingredient addition
-        if any(error for error in add_errors if error is not None):
-            self.fail(
-                "\n".join(
-                    error for error in add_errors if error is not None))
-
-        # Verify all ingredients were added successfully
-        self.assertEqual(
-            completed_threads,
-            5,
-            "All 5 threads should have completed")
-        self.assertEqual(
-            len(add_errors),
-            5,
-            "All 5 threads should have completed without errors")
-
-        # Now sign the manifest with the added ingredients
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            reader = Reader("image/jpeg", output)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-
-            # Verify active manifest exists
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-
-            # Verify active manifest object exists
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-
-            # Verify ingredients array exists in active manifest
-            self.assertIn("ingredients", active_manifest)
-            self.assertIsInstance(active_manifest["ingredients"], list)
-            self.assertEqual(len(active_manifest["ingredients"]), 5)
-
-            # Verify all ingredients exist in the array with correct thread IDs
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
-            for i in range(1, 6):
-                # Find an ingredient with this thread ID
-                thread_ingredients = [
-                    title for title in ingredient_titles if f"Thread {i}" in title]
-                self.assertEqual(
-                    len(thread_ingredients),
-                    1,
-                    f"Should find exactly one ingredient for thread {i}")
-
-                # Verify the ingredient title contains the file name
-                thread_ingredient = thread_ingredients[0]
-                file_name = selected_files[i - 1]
-                self.assertIn(
-                    file_name,
-                    thread_ingredient,
-                    f"Ingredient for thread {i} should contain its file name")
-
-        builder.close()
-
-    def test_builder_sign_with_multiple_ingredient_async_random(self):
-        """Test Builder class operations with 5 random ingredients added in parallel using asyncio."""
-        # Test creating builder from JSON
-        builder = Builder.from_json(self.manifestDefinition)
-        assert builder._builder is not None
-
-        # Get list of files from files-for-reading-tests directory
-        reading_dir = os.path.join(self.data_dir, "files-for-reading-tests")
-        all_files = [
-            f for f in os.listdir(reading_dir) if os.path.isfile(
-                os.path.join(
-                    reading_dir, f))]
-
-        # Select 5 random files
-        random.seed(42)  # For reproducible testing
-        selected_files = random.sample(all_files, 5)
-
-        # Async synchronization
-        add_errors = []
-        add_lock = asyncio.Lock()
-        completed_tasks = 0
-        completion_lock = asyncio.Lock()
-        # Barrier to synchronize task starts
-        start_barrier = asyncio.Barrier(5)
-
-        async def add_ingredient(file_name, task_id):
-            nonlocal completed_tasks
-            try:
-                # Wait for all tasks to be ready
-                await start_barrier.wait()
-
-                file_path = os.path.join(reading_dir, file_name)
-                ingredient_json = json.dumps({
-                    "title": f"Test Ingredient Task {task_id} - {file_name}"
-                })
-
-                with open(file_path, 'rb') as f:
-                    builder.add_ingredient(ingredient_json, "image/jpeg", f)
-
-                async with add_lock:
-                    add_errors.append(None)  # Success case
-            except Exception as e:
-                async with add_lock:
-                    add_errors.append(
-                        f"Task {task_id} error with file {file_name}: {
-                            str(e)}")
-            finally:
-                async with completion_lock:
-                    completed_tasks += 1
-
-        async def run_async_tests():
-            # Create all tasks first
-            tasks = []
-            for i, file_name in enumerate(selected_files, 1):
-                task = asyncio.create_task(add_ingredient(file_name, i))
-                tasks.append(task)
-
-            # Wait for all tasks to complete
-            await asyncio.gather(*tasks)
-
-            # Check for errors during ingredient addition
-            if any(error for error in add_errors if error is not None):
-                raise Exception(
-                    "\n".join(
-                        error for error in add_errors if error is not None))
-
-            # Verify all ingredients were added successfully
-            self.assertEqual(
-                completed_tasks,
-                5,
-                "All 5 tasks should have completed")
-            self.assertEqual(
-                len(add_errors),
-                5,
-                "All 5 tasks should have completed without errors")
-
-            # Now sign the manifest with the added ingredients
-            with open(self.testPath2, "rb") as file:
-                output = io.BytesIO(bytearray())
-                builder.sign(self.signer, "image/jpeg", file, output)
-                output.seek(0)
-                reader = Reader("image/jpeg", output)
-                json_data = reader.json()
-                manifest_data = json.loads(json_data)
-
-                # Verify active manifest exists
-                self.assertIn("active_manifest", manifest_data)
-                active_manifest_id = manifest_data["active_manifest"]
-
-                # Verify active manifest object exists
-                self.assertIn("manifests", manifest_data)
-                self.assertIn(active_manifest_id, manifest_data["manifests"])
-                active_manifest = manifest_data["manifests"][active_manifest_id]
-
-                # Verify ingredients array exists in active manifest
-                self.assertIn("ingredients", active_manifest)
-                self.assertIsInstance(active_manifest["ingredients"], list)
-                self.assertEqual(len(active_manifest["ingredients"]), 5)
-
-                # Verify all ingredients exist in the array with correct task
-                # IDs
-                ingredient_titles = [ing["title"]
-                                     for ing in active_manifest["ingredients"]]
-                for i in range(1, 6):
-                    # Find an ingredient with this task ID
-                    task_ingredients = [
-                        title for title in ingredient_titles if f"Task {i}" in title]
-                    self.assertEqual(
-                        len(task_ingredients),
-                        1,
-                        f"Should find exactly one ingredient for task {i}")
-
-                    # Verify the ingredient title contains the file name
-                    task_ingredient = task_ingredients[0]
-                    file_name = selected_files[i - 1]
-                    self.assertIn(file_name, task_ingredient, f"Ingredient for task {
-                                  i} should contain its file name")
-
-        # Run the async tests
-        asyncio.run(run_async_tests())
-        builder.close()
-
     def test_builder_sign_with_same_ingredient_multiple_times(self):
         """Test Builder class operations with the same ingredient added multiple times from different threads."""
         # Test creating builder from JSON