c2pa-python 0.10.0__tar.gz → 0.11.0__tar.gz

c2pa_python-0.11.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: c2pa-python
+Version: 0.11.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>
+License: MIT OR Apache-2.0
+Project-URL: homepage, https://contentauthenticity.org
+Project-URL: repository, https://github.com/contentauth/c2pa-python
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: wheel>=0.41.2
+Requires-Dist: setuptools>=68.0.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pytest>=7.4.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: requests>=2.0.0
+Dynamic: requires-python
+
+# C2PA Python library
+
+The [c2pa-python](https://github.com/contentauth/c2pa-python) repository provides a Python library that can:
+- Read and validate C2PA manifest data from media files in supported formats.
+- Create and sign manifest data, and attach it to media files in supported formats.
+
+Features:
+
+- Create and sign C2PA manifests using various signing algorithms.
+- Verify C2PA manifests and extract metadata.
+- Add assertions and ingredients to assets.
+- Examples and unit tests to demonstrate usage.
+
+## Prerequisites
+
+This library requires Python version 3.10+.
+
+## Package installation
+
+Install the c2pa-python package from PyPI by running:
+
+```bash
+pip install c2pa-python
+```
+
+To use the module in Python code, import the module like this:
+
+```python
+import c2pa
+```
+
+## Examples
+
+See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:
+- `examples/sign.py` shows how to sign and verify an asset with a C2PA manifest.
+- `examples/training.py` demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
+
+## Contributing
+
+Contributions are welcome!  For more information, see [Contributing to the project](https://github.com/contentauth/c2pa-python/blob/main/docs/project-contributions.md).
+
+## License
+
+This project is licensed under the Apache License 2.0 and the MIT License. See the [LICENSE-MIT](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-MIT) and [LICENSE-APACHE](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-APACHE) files for details.

c2pa_python-0.11.0/README.md

@@ -0,0 +1,44 @@
+# C2PA Python library
+
+The [c2pa-python](https://github.com/contentauth/c2pa-python) repository provides a Python library that can:
+- Read and validate C2PA manifest data from media files in supported formats.
+- Create and sign manifest data, and attach it to media files in supported formats.
+
+Features:
+
+- Create and sign C2PA manifests using various signing algorithms.
+- Verify C2PA manifests and extract metadata.
+- Add assertions and ingredients to assets.
+- Examples and unit tests to demonstrate usage.
+
+## Prerequisites
+
+This library requires Python version 3.10+.
+
+## Package installation
+
+Install the c2pa-python package from PyPI by running:
+
+```bash
+pip install c2pa-python
+```
+
+To use the module in Python code, import the module like this:
+
+```python
+import c2pa
+```
+
+## Examples
+
+See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:
+- `examples/sign.py` shows how to sign and verify an asset with a C2PA manifest.
+- `examples/training.py` demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
+
+## Contributing
+
+Contributions are welcome!  For more information, see [Contributing to the project](https://github.com/contentauth/c2pa-python/blob/main/docs/project-contributions.md).
+
+## License
+
+This project is licensed under the Apache License 2.0 and the MIT License. See the [LICENSE-MIT](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-MIT) and [LICENSE-APACHE](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-APACHE) files for details.

{c2pa_python-0.10.0 → c2pa_python-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "c2pa-python"
-version = "0.10.0"
+version = "0.11.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.10.0 → c2pa_python-0.11.0}/scripts/download_artifacts.py

@@ -46,16 +46,21 @@ def get_platform_identifier():
     Returns one of:
     - universal-apple-darwin (for Mac)
     - x86_64-pc-windows-msvc (for Windows 64-bit)
-    - x86_64-unknown-linux-gnu (for Linux 64-bit)
+    - x86_64-unknown-linux-gnu (for Linux x86_64)
+    - aarch64-unknown-linux-gnu (for Linux ARM64)
     """
     system = platform.system().lower()
+    machine = platform.machine().lower()
 
     if system == "darwin":
         return "universal-apple-darwin"
     elif system == "windows":
         return "x86_64-pc-windows-msvc"
     elif system == "linux":
-        return "x86_64-unknown-linux-gnu"
+        if machine in ["arm64", "aarch64"]:
+            return "aarch64-unknown-linux-gnu"
+        else:
+            return "x86_64-unknown-linux-gnu"
     else:
         raise ValueError(f"Unsupported operating system: {system}")
 
@@ -105,8 +110,12 @@ def copy_artifacts_to_root():
     print("Copying artifacts from scripts/artifacts to root...")
     if ROOT_ARTIFACTS_DIR.exists():
         shutil.rmtree(ROOT_ARTIFACTS_DIR)
+    print(f"Copying from {SCRIPTS_ARTIFACTS_DIR} to {ROOT_ARTIFACTS_DIR}")
     shutil.copytree(SCRIPTS_ARTIFACTS_DIR, ROOT_ARTIFACTS_DIR)
     print("Done copying artifacts")
+    print("\nFolder content of artifacts directory:")
+    for item in sorted(ROOT_ARTIFACTS_DIR.iterdir()):
+        print(f"  {item.name}")
 
 def main():
     if len(sys.argv) < 2:
@@ -126,6 +135,8 @@ def main():
         if env_platform:
             print(f"Using platform from environment variable C2PA_LIBS_PLATFORM: {env_platform}")
         platform_id = env_platform or get_platform_identifier()
+        print("Looking up releases for platform id: ", platform_id)
+        print("Environment variable set for lookup: ", env_platform)
         platform_source = "environment variable" if env_platform else "auto-detection"
         print(f"Target platform: {platform_id} (set through{platform_source})")
 

{c2pa_python-0.10.0 → c2pa_python-0.11.0}/setup.py

@@ -30,6 +30,7 @@ PLATFORM_FOLDERS = {
     'x86_64-apple-darwin': 'dylib',
     'x86_64-pc-windows-msvc': 'dll',
     'x86_64-unknown-linux-gnu': 'so',
+    'aarch64-unknown-linux-gnu': 'so',  # Add ARM Linux support
 }
 
 # Directory structure
@@ -51,6 +52,7 @@ def get_platform_identifier(cpu_arch = None) -> str:
     - x86_64-apple-darwin (for Mac x86_64)
     - x86_64-pc-windows-msvc (for Windows 64-bit)
     - x86_64-unknown-linux-gnu (for Linux 64-bit)
+    - aarch64-unknown-linux-gnu (for Linux ARM64)
     """
     system = platform.system().lower()
 
@@ -66,6 +68,8 @@ def get_platform_identifier(cpu_arch = None) -> str:
     elif system == "windows":
         return "x86_64-pc-windows-msvc"
     elif system == "linux":
+        if platform.machine() == "aarch64":
+            return "aarch64-unknown-linux-gnu"
         return "x86_64-unknown-linux-gnu"
     else:
         raise ValueError(f"Unsupported operating system: {system}")

{c2pa_python-0.10.0 → c2pa_python-0.11.0}/src/c2pa/lib.py

@@ -62,6 +62,8 @@ def get_platform_identifier(cpu_arch: Optional[CPUArchitecture] = None) -> str:
     elif system == "windows":
         return "x86_64-pc-windows-msvc"
     elif system == "linux":
+        if _get_architecture() in ['arm64', 'aarch64']:
+            return "aarch64-unknown-linux-gnu"
         return "x86_64-unknown-linux-gnu"
     else:
         raise ValueError(f"Unsupported operating system: {system}")
@@ -245,8 +247,11 @@ def dynamically_load_library(
         # If specific library name is provided, only load that one
         lib = _load_single_library(lib_name, possible_paths)
         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]}")
-            raise RuntimeError(f"Could not find {lib_name} in any of the search 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.11.0/src/c2pa_python.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: c2pa-python
+Version: 0.11.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>
+License: MIT OR Apache-2.0
+Project-URL: homepage, https://contentauthenticity.org
+Project-URL: repository, https://github.com/contentauth/c2pa-python
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: wheel>=0.41.2
+Requires-Dist: setuptools>=68.0.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pytest>=7.4.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: requests>=2.0.0
+Dynamic: requires-python
+
+# C2PA Python library
+
+The [c2pa-python](https://github.com/contentauth/c2pa-python) repository provides a Python library that can:
+- Read and validate C2PA manifest data from media files in supported formats.
+- Create and sign manifest data, and attach it to media files in supported formats.
+
+Features:
+
+- Create and sign C2PA manifests using various signing algorithms.
+- Verify C2PA manifests and extract metadata.
+- Add assertions and ingredients to assets.
+- Examples and unit tests to demonstrate usage.
+
+## Prerequisites
+
+This library requires Python version 3.10+.
+
+## Package installation
+
+Install the c2pa-python package from PyPI by running:
+
+```bash
+pip install c2pa-python
+```
+
+To use the module in Python code, import the module like this:
+
+```python
+import c2pa
+```
+
+## Examples
+
+See the [`examples` directory](https://github.com/contentauth/c2pa-python/tree/main/examples) for some helpful examples:
+- `examples/sign.py` shows how to sign and verify an asset with a C2PA manifest.
+- `examples/training.py` demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
+
+## Contributing
+
+Contributions are welcome!  For more information, see [Contributing to the project](https://github.com/contentauth/c2pa-python/blob/main/docs/project-contributions.md).
+
+## License
+
+This project is licensed under the Apache License 2.0 and the MIT License. See the [LICENSE-MIT](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-MIT) and [LICENSE-APACHE](https://github.com/contentauth/c2pa-python/blob/main/LICENSE-APACHE) files for details.

{c2pa_python-0.10.0 → c2pa_python-0.11.0}/tests/test_unit_tests.py

@@ -212,6 +212,30 @@ class TestReader(unittest.TestCase):
             except Exception as e:
                 self.fail(f"Failed to read metadata from {filename}: {str(e)}")
 
+    def test_read_cawg_data_file(self):
+        """Test reading C2PA metadata from C_with_CAWG_data.jpg file."""
+        file_path = os.path.join(self.data_dir, "files-for-reading-tests", "C_with_CAWG_data.jpg")
+
+        with open(file_path, "rb") as file:
+            reader = Reader("image/jpeg", file)
+            json_data = reader.json()
+            self.assertIsInstance(json_data, str)
+
+            # Parse the JSON and verify specific fields
+            manifest_data = json.loads(json_data)
+
+            # Verify basic manifest structure
+            self.assertIn("manifests", manifest_data)
+            self.assertIn("active_manifest", manifest_data)
+
+            # Get the active manifest
+            active_manifest_id = manifest_data["active_manifest"]
+            active_manifest = manifest_data["manifests"][active_manifest_id]
+
+            # Verify manifest is not null or empty
+            assert active_manifest is not None, "Active manifest should not be null"
+            assert len(active_manifest) > 0, "Active manifest should not be empty"
+
 
 class TestBuilder(unittest.TestCase):
     def setUp(self):

{c2pa_python-0.10.0 → c2pa_python-0.11.0}/tests/test_unit_tests_threaded.py

@@ -2096,32 +2096,22 @@ class TestBuilderWithThreads(unittest.TestCase):
         builder.close()
 
     def test_builder_sign_with_multiple_ingredient_random_many_threads(self):
-        """Test Builder class operations with 10 threads, each adding 3 random ingredients and signing a random file."""
+        """Test Builder class operations with 12 threads, each adding 3 specific ingredients and signing a file."""
         # Number of threads to use in the test
-        # We are pushing it here, as we want to test with thread count one to two orders of magnitude
-        # higher than "usual" max numbers of cores on (server) machines may be.
-
         TOTAL_THREADS_USED = 12
 
-        # Get list of files from files-for-reading-tests directory
-        reading_dir = os.path.join(self.data_dir, "files-for-reading-tests")
-
-        # Filter for JPG and PNG files only
-        all_files = [
-            f for f in os.listdir(reading_dir)
-            if os.path.isfile(os.path.join(reading_dir, f))
-            and os.path.splitext(f)[1].lower() in {'.jpg', '.jpeg', '.png'}
+        # Define the specific files to use as ingredients
+        # THose files should be valid to use as ingredient
+        ingredient_files = [
+            os.path.join(self.data_dir, "A_thumbnail.jpg"),
+            os.path.join(self.data_dir, "C.jpg"),
+            os.path.join(self.data_dir, "cloud.jpg")
         ]
 
-        # Ensure we have enough files
-        self.assertGreaterEqual(
-            len(all_files),
-            3,
-            "Need at least 3 JPG/PNG files for testing")
-
         # Thread synchronization
         thread_results = {}
         completed_threads = 0
+        thread_lock = threading.Lock()  # Lock for thread-safe access to shared data
 
         def thread_work(thread_id):
             nonlocal completed_threads
@@ -2129,24 +2119,17 @@ class TestBuilderWithThreads(unittest.TestCase):
                 # Create a new builder for this thread
                 builder = Builder.from_json(self.manifestDefinition)
 
-                # Select 3 random files for ingredients
-                # Use thread_id as seed for reproducibility
-                random.seed(thread_id)
-                ingredient_files = random.sample(all_files, 3)
-
                 # Add each ingredient
-                for i, file_name in enumerate(ingredient_files, 1):
-                    file_path = os.path.join(reading_dir, file_name)
+                for i, file_path in enumerate(ingredient_files, 1):
                     ingredient_json = json.dumps({
-                        "title": f"Thread {thread_id} Ingredient {i} - {file_name}"
+                        "title": f"Thread {thread_id} Ingredient {i} - {os.path.basename(file_path)}"
                     })
 
                     with open(file_path, 'rb') as f:
                         builder.add_ingredient(ingredient_json, "image/jpeg", f)
 
-                # Select a random file for signing
-                sign_file = random.choice(all_files)
-                sign_file_path = os.path.join(reading_dir, sign_file)
+                # Use A.jpg as the file to sign
+                sign_file_path = os.path.join(self.data_dir, "A.jpg")
 
                 # Sign the file
                 with open(sign_file_path, "rb") as file:
@@ -2168,11 +2151,13 @@ class TestBuilderWithThreads(unittest.TestCase):
                     manifest_data = json.loads(json_data)
 
                     # Store results for verification
-                    thread_results[thread_id] = {
-                        'manifest': manifest_data,
-                        'ingredient_files': ingredient_files,
-                        'sign_file': sign_file
-                    }
+                    with thread_lock:
+                        thread_results[thread_id] = {
+                            'manifest': manifest_data,
+                            'ingredient_files': [os.path.basename(f) for f in ingredient_files],
+                            'sign_file': os.path.basename(sign_file_path),
+                            'manifest_hash': hash(json.dumps(manifest_data, sort_keys=True))  # Add hash for comparison
+                        }
 
                     # Clean up streams
                     output.close()
@@ -2181,11 +2166,13 @@ class TestBuilderWithThreads(unittest.TestCase):
                 builder.close()
 
             except Exception as e:
-                thread_results[thread_id] = {
-                    'error': str(e)
-                }
+                with thread_lock:
+                    thread_results[thread_id] = {
+                        'error': str(e)
+                    }
             finally:
-                completed_threads += 1
+                with thread_lock:
+                    completed_threads += 1
 
         # Create and start threads
         threads = []
@@ -2199,26 +2186,31 @@ class TestBuilderWithThreads(unittest.TestCase):
             thread.join()
 
         # Verify all threads completed
-        self.assertEqual(completed_threads, TOTAL_THREADS_USED, f"All {
-                         TOTAL_THREADS_USED} threads should have completed")
+        self.assertEqual(completed_threads, TOTAL_THREADS_USED, f"All {TOTAL_THREADS_USED} threads should have completed")
         self.assertEqual(
             len(thread_results),
             TOTAL_THREADS_USED,
             f"Should have results from all {TOTAL_THREADS_USED} threads")
 
+        # Collect all manifest hashes for comparison
+        manifest_hashes = set()
+        thread_manifest_data = {}
+
         # Verify results for each thread
         for thread_id in range(1, TOTAL_THREADS_USED + 1):
             result = thread_results[thread_id]
 
             # Check if thread encountered an error
             if 'error' in result:
-                self.fail(
-                    f"Thread {thread_id} failed with error: {
-                        result['error']}")
+                self.fail(f"Thread {thread_id} failed with error: {result['error']}")
 
             manifest_data = result['manifest']
             ingredient_files = result['ingredient_files']
-            sign_file = result['sign_file']
+            manifest_hash = result['manifest_hash']
+
+            # Store manifest data for cross-thread comparison
+            thread_manifest_data[thread_id] = manifest_data
+            manifest_hashes.add(manifest_hash)
 
             # Verify active manifest exists
             self.assertIn("active_manifest", manifest_data)
@@ -2234,16 +2226,44 @@ class TestBuilderWithThreads(unittest.TestCase):
             self.assertIsInstance(active_manifest["ingredients"], list)
             self.assertEqual(len(active_manifest["ingredients"]), 3)
 
-            # Verify all ingredients exist with correct thread ID and file
-            # names
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
+            # Verify all ingredients exist with correct thread ID and file names
+            ingredient_titles = [ing["title"] for ing in active_manifest["ingredients"]]
             for i, file_name in enumerate(ingredient_files, 1):
-                expected_title = f"Thread {
-                    thread_id} Ingredient {i} - {file_name}"
-                self.assertIn(expected_title, ingredient_titles, f"Thread {
-                              thread_id} should have ingredient with title {expected_title}")
+                expected_title = f"Thread {thread_id} Ingredient {i} - {file_name}"
+                self.assertIn(expected_title, ingredient_titles, f"Thread {thread_id} should have ingredient with title {expected_title}")
+
+            # Verify no cross-thread contamination in ingredient titles
+            for other_thread_id in range(1, TOTAL_THREADS_USED + 1):
+                if other_thread_id != thread_id:
+                    for title in ingredient_titles:
+                        # Check for exact thread ID pattern to avoid false positives
+                        self.assertNotIn(
+                            f"Thread {other_thread_id} Ingredient",
+                            title,
+                            f"Thread {thread_id}'s manifest contains ingredient data from thread {other_thread_id}")
+
+        # Verify all manifests are unique (no data scrambling between threads)
+        self.assertEqual(
+            len(manifest_hashes),
+            TOTAL_THREADS_USED,
+            "Each thread should have a unique manifest (no data scrambling)")
 
+        # Additional verification: Compare manifest structures between threads
+        for thread_id in range(1, TOTAL_THREADS_USED + 1):
+            current_manifest = thread_manifest_data[thread_id]
+
+            # Verify manifest structure is consistent
+            self.assertIn("active_manifest", current_manifest)
+            self.assertIn("manifests", current_manifest)
+
+            # Verify no cross-thread contamination in manifest data
+            for other_thread_id in range(1, TOTAL_THREADS_USED + 1):
+                if other_thread_id != thread_id:
+                    other_manifest = thread_manifest_data[other_thread_id]
+                    self.assertNotEqual(
+                        current_manifest["active_manifest"],
+                        other_manifest["active_manifest"],
+                        f"Thread {thread_id} and {other_thread_id} share the same active manifest ID")
 
 if __name__ == '__main__':
     unittest.main()

c2pa_python-0.10.0/PKG-INFO

@@ -1,156 +0,0 @@
-Metadata-Version: 2.4
-Name: c2pa-python
-Version: 0.10.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>
-License: MIT OR Apache-2.0
-Project-URL: homepage, https://contentauthenticity.org
-Project-URL: repository, https://github.com/contentauth/c2pa-python
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: wheel>=0.41.2
-Requires-Dist: setuptools>=68.0.0
-Requires-Dist: toml>=0.10.2
-Requires-Dist: pytest>=7.4.0
-Requires-Dist: cryptography>=41.0.0
-Requires-Dist: requests>=2.0.0
-Dynamic: requires-python
-
-# Python API for C2PA
-
-This project provides a Python API for working with [C2PA](https://c2pa.org/) (Coalition for Content Provenance and Authenticity) manifests. It includes functionality for creating, signing, and verifying C2PA manifests, as well as working with assets and assertions.
-
-## Features
-
-- Create and sign C2PA manifests using various signing algorithms.
-- Verify C2PA manifests and extract metadata.
-- Add assertions and ingredients to assets.
-- Examples and unit tests to demonstrate usage.
-
-## Project Structure
-
-```bash
-.
-├── .github/                  # GitHub configuration files
-├── artifacts/                # Platform-specific libraries for building (per subfolder)
-│   └── your_target_platform/ # Platform-specific artifacts
-├── docs/                     # Project documentation
-├── examples/                 # Example scripts demonstrating usage
-├── scripts/                  # Utility scripts (eg. artifacts download)
-├── src/                      # Source code
-│   └── c2pa/                 # Main package directory
-│       └── libs/             # Platform-specific libraries
-├── tests/                    # Unit tests and benchmarks
-├── .gitignore                # Git ignore rules
-├── Makefile                  # Build and development commands
-├── pyproject.toml            # Python project configuration
-├── requirements.txt          # Python dependencies
-├── requirements-dev.txt      # Development dependencies
-└── setup.py                  # Package setup script
-```
-
-## Package installation
-
-The c2pa-python package is published to PyPI. You can install it from there by running:
-
-```bash
-pip install c2pa-python
-```
-
-To use the module in your Python code, import like this:
-
-```python
-import c2pa
-```
-
-## Examples
-
-### Adding a "Do Not Train" Assertion
-
-The `examples/training.py` script demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
-
-### Signing and Verifying Assets
-
-The `examples/sign.py` script shows how to sign an asset with a C2PA manifest and verify it.
-
-## Development Setup
-
-1. Create and activate a virtual environment with native dependencies:
-
-```bash
-# Create virtual environment
-python -m venv .venv
-
-# Activate virtual environment
-# On Windows:
-.venv\Scripts\activate
-# On macOS/Linux:
-source .venv/bin/activate
-
-# load project dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-
-# download library artifacts for the current version you want, eg v0.55.0
-python scripts/download_artifacts.py c2pa-v0.55.0
-```
-
-2. Install the package in development mode:
-
-```bash
-pip install -e .
-```
-
-This will:
-
-- Copy the appropriate libraries for your platform from `artifacts/` to `src/c2pa/libs/`
-- Install the package in development mode, allowing you to make changes to the Python code without reinstalling
-
-## Building Wheels
-
-To build wheels for all platforms that have libraries in the `artifacts/` directory:
-
-```bash
-python setup.py bdist_wheel
-```
-
-You can use `twine` to verify the wheels have correct metadata:
-
-```bash
-twine check dist/*
-```
-
-This will create platform-specific wheels in the `dist/` directory.
-
-## Running Tests
-
-Run the tests:
-
-```bash
-make test
-```
-
-Alternatively, install pytest (if not already installed):
-
-```bash
-pip install pytest
-```
-
-And run:
-
-```bash
-pytest
-```
-
-## Contributing
-
-Contributions are welcome! Please fork the repository and submit a pull request.
-
-## License
-
-This project is licensed under the Apache License 2.0 or the MIT License. See the LICENSE-MIT and LICENSE-APACHE files for details.

c2pa_python-0.10.0/README.md

@@ -1,133 +0,0 @@
-# Python API for C2PA
-
-This project provides a Python API for working with [C2PA](https://c2pa.org/) (Coalition for Content Provenance and Authenticity) manifests. It includes functionality for creating, signing, and verifying C2PA manifests, as well as working with assets and assertions.
-
-## Features
-
-- Create and sign C2PA manifests using various signing algorithms.
-- Verify C2PA manifests and extract metadata.
-- Add assertions and ingredients to assets.
-- Examples and unit tests to demonstrate usage.
-
-## Project Structure
-
-```bash
-.
-├── .github/                  # GitHub configuration files
-├── artifacts/                # Platform-specific libraries for building (per subfolder)
-│   └── your_target_platform/ # Platform-specific artifacts
-├── docs/                     # Project documentation
-├── examples/                 # Example scripts demonstrating usage
-├── scripts/                  # Utility scripts (eg. artifacts download)
-├── src/                      # Source code
-│   └── c2pa/                 # Main package directory
-│       └── libs/             # Platform-specific libraries
-├── tests/                    # Unit tests and benchmarks
-├── .gitignore                # Git ignore rules
-├── Makefile                  # Build and development commands
-├── pyproject.toml            # Python project configuration
-├── requirements.txt          # Python dependencies
-├── requirements-dev.txt      # Development dependencies
-└── setup.py                  # Package setup script
-```
-
-## Package installation
-
-The c2pa-python package is published to PyPI. You can install it from there by running:
-
-```bash
-pip install c2pa-python
-```
-
-To use the module in your Python code, import like this:
-
-```python
-import c2pa
-```
-
-## Examples
-
-### Adding a "Do Not Train" Assertion
-
-The `examples/training.py` script demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
-
-### Signing and Verifying Assets
-
-The `examples/sign.py` script shows how to sign an asset with a C2PA manifest and verify it.
-
-## Development Setup
-
-1. Create and activate a virtual environment with native dependencies:
-
-```bash
-# Create virtual environment
-python -m venv .venv
-
-# Activate virtual environment
-# On Windows:
-.venv\Scripts\activate
-# On macOS/Linux:
-source .venv/bin/activate
-
-# load project dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-
-# download library artifacts for the current version you want, eg v0.55.0
-python scripts/download_artifacts.py c2pa-v0.55.0
-```
-
-2. Install the package in development mode:
-
-```bash
-pip install -e .
-```
-
-This will:
-
-- Copy the appropriate libraries for your platform from `artifacts/` to `src/c2pa/libs/`
-- Install the package in development mode, allowing you to make changes to the Python code without reinstalling
-
-## Building Wheels
-
-To build wheels for all platforms that have libraries in the `artifacts/` directory:
-
-```bash
-python setup.py bdist_wheel
-```
-
-You can use `twine` to verify the wheels have correct metadata:
-
-```bash
-twine check dist/*
-```
-
-This will create platform-specific wheels in the `dist/` directory.
-
-## Running Tests
-
-Run the tests:
-
-```bash
-make test
-```
-
-Alternatively, install pytest (if not already installed):
-
-```bash
-pip install pytest
-```
-
-And run:
-
-```bash
-pytest
-```
-
-## Contributing
-
-Contributions are welcome! Please fork the repository and submit a pull request.
-
-## License
-
-This project is licensed under the Apache License 2.0 or the MIT License. See the LICENSE-MIT and LICENSE-APACHE files for details.

c2pa_python-0.10.0/src/c2pa_python.egg-info/PKG-INFO

@@ -1,156 +0,0 @@
-Metadata-Version: 2.4
-Name: c2pa-python
-Version: 0.10.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>
-License: MIT OR Apache-2.0
-Project-URL: homepage, https://contentauthenticity.org
-Project-URL: repository, https://github.com/contentauth/c2pa-python
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: wheel>=0.41.2
-Requires-Dist: setuptools>=68.0.0
-Requires-Dist: toml>=0.10.2
-Requires-Dist: pytest>=7.4.0
-Requires-Dist: cryptography>=41.0.0
-Requires-Dist: requests>=2.0.0
-Dynamic: requires-python
-
-# Python API for C2PA
-
-This project provides a Python API for working with [C2PA](https://c2pa.org/) (Coalition for Content Provenance and Authenticity) manifests. It includes functionality for creating, signing, and verifying C2PA manifests, as well as working with assets and assertions.
-
-## Features
-
-- Create and sign C2PA manifests using various signing algorithms.
-- Verify C2PA manifests and extract metadata.
-- Add assertions and ingredients to assets.
-- Examples and unit tests to demonstrate usage.
-
-## Project Structure
-
-```bash
-.
-├── .github/                  # GitHub configuration files
-├── artifacts/                # Platform-specific libraries for building (per subfolder)
-│   └── your_target_platform/ # Platform-specific artifacts
-├── docs/                     # Project documentation
-├── examples/                 # Example scripts demonstrating usage
-├── scripts/                  # Utility scripts (eg. artifacts download)
-├── src/                      # Source code
-│   └── c2pa/                 # Main package directory
-│       └── libs/             # Platform-specific libraries
-├── tests/                    # Unit tests and benchmarks
-├── .gitignore                # Git ignore rules
-├── Makefile                  # Build and development commands
-├── pyproject.toml            # Python project configuration
-├── requirements.txt          # Python dependencies
-├── requirements-dev.txt      # Development dependencies
-└── setup.py                  # Package setup script
-```
-
-## Package installation
-
-The c2pa-python package is published to PyPI. You can install it from there by running:
-
-```bash
-pip install c2pa-python
-```
-
-To use the module in your Python code, import like this:
-
-```python
-import c2pa
-```
-
-## Examples
-
-### Adding a "Do Not Train" Assertion
-
-The `examples/training.py` script demonstrates how to add a "Do Not Train" assertion to an asset and verify it.
-
-### Signing and Verifying Assets
-
-The `examples/sign.py` script shows how to sign an asset with a C2PA manifest and verify it.
-
-## Development Setup
-
-1. Create and activate a virtual environment with native dependencies:
-
-```bash
-# Create virtual environment
-python -m venv .venv
-
-# Activate virtual environment
-# On Windows:
-.venv\Scripts\activate
-# On macOS/Linux:
-source .venv/bin/activate
-
-# load project dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-
-# download library artifacts for the current version you want, eg v0.55.0
-python scripts/download_artifacts.py c2pa-v0.55.0
-```
-
-2. Install the package in development mode:
-
-```bash
-pip install -e .
-```
-
-This will:
-
-- Copy the appropriate libraries for your platform from `artifacts/` to `src/c2pa/libs/`
-- Install the package in development mode, allowing you to make changes to the Python code without reinstalling
-
-## Building Wheels
-
-To build wheels for all platforms that have libraries in the `artifacts/` directory:
-
-```bash
-python setup.py bdist_wheel
-```
-
-You can use `twine` to verify the wheels have correct metadata:
-
-```bash
-twine check dist/*
-```
-
-This will create platform-specific wheels in the `dist/` directory.
-
-## Running Tests
-
-Run the tests:
-
-```bash
-make test
-```
-
-Alternatively, install pytest (if not already installed):
-
-```bash
-pip install pytest
-```
-
-And run:
-
-```bash
-pytest
-```
-
-## Contributing
-
-Contributions are welcome! Please fork the repository and submit a pull request.
-
-## License
-
-This project is licensed under the Apache License 2.0 or the MIT License. See the LICENSE-MIT and LICENSE-APACHE files for details.