trainingsample 0.3.1__tar.gz → 0.3.2__tar.gz

{trainingsample-0.3.1 → trainingsample-0.3.2}/.github/workflows/ci.yml

@@ -108,7 +108,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
     - uses: actions/checkout@v4
@@ -387,7 +387,7 @@ jobs:
     runs-on: ubuntu-24.04-arm
     strategy:
       matrix:
-        python: ["3.11", "3.12", "3.13"]
+        python: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
     - uses: actions/checkout@v4
@@ -434,7 +434,6 @@ jobs:
         container: off
         manylinux: manylinux_2_39
       env:
-        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: '1'
         LIBCLANG_PATH: ${{ env.LIBCLANG_PATH }}
         LLVM_CONFIG_PATH: ${{ env.LLVM_CONFIG_PATH }}
         OPENCV_INCLUDE_PATHS: ${{ github.workspace }}/third_party/opencv-static/include/opencv4

{trainingsample-0.3.1 → trainingsample-0.3.2}/.github/workflows/publish.yml

@@ -25,6 +25,10 @@ jobs:
             target: x86_64
             manylinux: manylinux_2_35
             python: '3.13'
+          - os: ubuntu-22.04
+            target: x86_64
+            manylinux: manylinux_2_35
+            python: '3.14'
           # Ubuntu 24.04 (libc 2.39)
           - os: ubuntu-24.04
             target: x86_64
@@ -38,6 +42,10 @@ jobs:
             target: x86_64
             manylinux: manylinux_2_39
             python: '3.13'
+          - os: ubuntu-24.04
+            target: x86_64
+            manylinux: manylinux_2_39
+            python: '3.14'
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-python@v5
@@ -104,8 +112,6 @@ jobs:
         container: off
         manylinux: ${{ matrix.manylinux }}
       env:
-        # Use stable ABI for forward compatibility
-        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: '1'
         # LLVM for opencv-rust bindings (from earlier install step)
         LIBCLANG_PATH: ${{ env.LIBCLANG_PATH }}
         LLVM_CONFIG_PATH: ${{ env.LLVM_CONFIG_PATH }}
@@ -135,7 +141,7 @@ jobs:
     runs-on: ubuntu-24.04-arm
     strategy:
       matrix:
-        python: ['3.11', '3.12', '3.13']
+        python: ['3.11', '3.12', '3.13', '3.14']
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-python@v5
@@ -186,8 +192,6 @@ jobs:
         container: off
         manylinux: manylinux_2_39
       env:
-        # Use stable ABI for forward compatibility
-        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: '1'
         # LLVM for opencv-rust bindings (from earlier install step)
         LIBCLANG_PATH: ${{ env.LIBCLANG_PATH }}
         LLVM_CONFIG_PATH: ${{ env.LLVM_CONFIG_PATH }}
@@ -217,7 +221,7 @@ jobs:
     strategy:
       matrix:
         target: [aarch64]
-        python: ['3.11', '3.12', '3.13']
+        python: ['3.11', '3.12', '3.13', '3.14']
     steps:
     - uses: actions/checkout@v4
     - uses: actions/setup-python@v5
@@ -251,8 +255,6 @@ jobs:
         args: --release --out dist -i python --no-default-features --features python-bindings,simd,opencv,metal
         sccache: 'false'
       env:
-        # Use stable ABI for forward compatibility
-        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: '1'
         # OpenCV static linking configuration
         OPENCV_INCLUDE_PATHS: ${{ github.workspace }}/third_party/opencv-static/include/opencv4
         OPENCV_LINK_PATHS: ${{ github.workspace }}/third_party/opencv-static/lib
@@ -306,6 +308,11 @@ jobs:
             manylinux: manylinux_2_35
             python: '3.13'
             artifact_name: wheels-ubuntu-22.04-x86_64-py3.13
+          - os: ubuntu-22.04
+            target: x86_64
+            manylinux: manylinux_2_35
+            python: '3.14'
+            artifact_name: wheels-ubuntu-22.04-x86_64-py3.14
           # Ubuntu 24.04 (libc 2.39)
           - os: ubuntu-24.04
             target: x86_64
@@ -322,6 +329,11 @@ jobs:
             manylinux: manylinux_2_39
             python: '3.13'
             artifact_name: wheels-ubuntu-24.04-x86_64-py3.13
+          - os: ubuntu-24.04
+            target: x86_64
+            manylinux: manylinux_2_39
+            python: '3.14'
+            artifact_name: wheels-ubuntu-24.04-x86_64-py3.14
           # Linux aarch64 (DGX Spark / GB10)
           - os: ubuntu-24.04-arm
             target: aarch64
@@ -338,6 +350,11 @@ jobs:
             manylinux: manylinux_2_39
             python: '3.13'
             artifact_name: wheels-linux-aarch64-py3.13
+          - os: ubuntu-24.04-arm
+            target: aarch64
+            manylinux: manylinux_2_39
+            python: '3.14'
+            artifact_name: wheels-linux-aarch64-py3.14
           # macOS aarch64
           - os: macos-latest
             target: aarch64
@@ -354,6 +371,11 @@ jobs:
             manylinux: ''
             python: '3.13'
             artifact_name: wheels-macos-latest-aarch64-py3.13
+          - os: macos-latest
+            target: aarch64
+            manylinux: ''
+            python: '3.14'
+            artifact_name: wheels-macos-latest-aarch64-py3.14
     steps:
     - uses: actions/download-artifact@v4
       with:

{trainingsample-0.3.1 → trainingsample-0.3.2}/Cargo.lock

@@ -224,9 +224,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.4.2"
+version = "1.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d262e149917187838d5b42777c8253bcb64500067342904e7d429499a6f277e"
+checksum = "0ad534f4357a5264cce5019c989cf66a4f0dc4e0d1b1d15f8aacec0ff7360273"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -348,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+checksum = "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550"
 dependencies = [
  "cfg-if",
 ]
@@ -430,9 +430,9 @@ checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
 [[package]]
 name = "either"
-version = "1.17.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
 
 [[package]]
 name = "equator"
@@ -504,9 +504,9 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b73573e6edcd2af0cdf47bd6cb58f0b3839491263c314eaad1ccf24430e1de"
+checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"
 
 [[package]]
 name = "flate2"
@@ -536,7 +536,7 @@ checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.4",
 ]
 
 [[package]]
@@ -547,21 +547,21 @@ checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
 
 [[package]]
 name = "futures-core"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
 
 [[package]]
 name = "futures-task"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
 
 [[package]]
 name = "futures-util"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -833,9 +833,9 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "log"
-version = "0.4.33"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "loop9"
@@ -942,9 +942,9 @@ dependencies = [
 
 [[package]]
 name = "ndarray"
-version = "0.16.1"
+version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
+checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
 dependencies = [
  "matrixmultiply",
  "num-complex",
@@ -1032,9 +1032,9 @@ dependencies = [
 
 [[package]]
 name = "num-integer"
-version = "0.1.46"
+version = "0.1.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
 dependencies = [
  "num-traits",
 ]
@@ -1082,9 +1082,9 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.22.1"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edb929bc0da91a4d85ed6c0a84deaa53d411abfb387fc271124f91bf6b89f14e"
+checksum = "7aac2e6a6e4468ffa092ad43c39b81c79196c2bb773b8db4085f695efe3bba17"
 dependencies = [
  "libc",
  "ndarray",
@@ -1092,6 +1092,7 @@ dependencies = [
  "num-integer",
  "num-traits",
  "pyo3",
+ "pyo3-build-config",
  "rustc-hash",
 ]
 
@@ -1196,9 +1197,9 @@ checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
 
 [[package]]
 name = "plotters"
@@ -1324,11 +1325,10 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -1342,19 +1342,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.6"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1362,9 +1361,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1374,9 +1373,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1618,9 +1617,9 @@ checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 
 [[package]]
 name = "rustix"
@@ -1692,7 +1691,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.4",
 ]
 
 [[package]]
@@ -1773,9 +1772,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1784,9 +1783,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tempfile"
@@ -1818,7 +1817,7 @@ checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.4",
 ]
 
 [[package]]
@@ -1847,7 +1846,7 @@ dependencies = [
 
 [[package]]
 name = "trainingsample"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "anyhow",
  "criterion",

{trainingsample-0.3.1 → trainingsample-0.3.2}/Cargo.toml

@@ -5,15 +5,15 @@ image = {version = "0.25", features = ["png", "jpeg", "webp"]}
 imageproc = "0.25"
 # Metal GPU acceleration
 metal = {version = "0.27", optional = true}
-ndarray = "0.16"
+ndarray = "0.17"
 num_cpus = "1.16"
-numpy = {version = "0.22", optional = true}
+numpy = {version = "0.27", optional = true}
 objc = {version = "0.2", optional = true}
 # OpenCV bindings for performance parity
 # Limit binding generation to the modules this crate actually uses.
 opencv = {version = "0.99", optional = true, default-features = false, features = ["clang-runtime", "imgproc", "videoio"]}
 # Python bindings (optional)
-pyo3 = {version = "0.22", features = ["extension-module"], optional = true}
+pyo3 = {version = "0.27", features = ["extension-module"], optional = true}
 rayon = "1.8"
 tempfile = {version = "3.10", optional = true}
 # SIMD optimizations
@@ -39,7 +39,7 @@ description = "High-performance Rust reimplementation of GIL-blocking video/imag
 edition = "2021"
 license = "MIT"
 name = "trainingsample"
-version = "0.3.1"
+version = "0.3.2"
 readme = "README.md"
 
 [profile.release]

{trainingsample-0.3.1 → trainingsample-0.3.2}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: trainingsample
-Version: 0.3.1
+Version: 0.3.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pillow>=8.0.0
 Requires-Dist: pytest>=6.0 ; extra == 'dev'
 Requires-Dist: pytest-benchmark ; extra == 'dev'
-Requires-Dist: maturin>=1.0,<2.0 ; extra == 'dev'
+Requires-Dist: maturin>=1.9.5,<2.0 ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE

{trainingsample-0.3.1 → trainingsample-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 build-backend = "maturin"
-requires = ["maturin>=1.0,<2.0"]
+requires = ["maturin>=1.9.5,<2.0"]
 
 [project]
 authors = [{name = "bghira", email = "bghira@users.noreply.github.com"}]
@@ -10,17 +10,18 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13"
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14"
 ]
 dependencies = ["numpy>=1.21.0", "pillow>=8.0.0"]
 description = "High-performance Rust reimplementation of GIL-blocking video/image operations"
 license = {text = "MIT"}
 name = "trainingsample"
 requires-python = ">=3.11"
-version = "0.3.1"
+version = "0.3.2"
 
 [project.optional-dependencies]
-dev = ["pytest>=6.0", "pytest-benchmark", "maturin>=1.0,<2.0", "pre-commit"]
+dev = ["pytest>=6.0", "pytest-benchmark", "maturin>=1.9.5,<2.0", "pre-commit"]
 
 [tool.black]
 extend-exclude = '''

{trainingsample-0.3.1 → trainingsample-0.3.2}/src/python_bindings.rs

@@ -88,7 +88,7 @@ impl BufferPool {
 
 #[cfg(feature = "python-bindings")]
 #[pyfunction]
-pub fn load_image_batch(py: Python, image_paths: Vec<String>) -> PyResult<Vec<PyObject>> {
+pub fn load_image_batch(py: Python, image_paths: Vec<String>) -> PyResult<Vec<Py<PyAny>>> {
     use rayon::prelude::*;
 
     let results: Vec<_> = image_paths
@@ -100,7 +100,7 @@ pub fn load_image_batch(py: Python, image_paths: Vec<String>) -> PyResult<Vec<Py
     for result in results {
         match result {
             Ok(image_data) => {
-                let py_bytes = PyBytes::new_bound(py, &image_data);
+                let py_bytes = PyBytes::new(py, &image_data);
                 py_results.push(py_bytes.into_any().unbind());
             }
             Err(_) => {
@@ -155,7 +155,7 @@ pub unsafe fn batch_crop_images_zero_copy<'py>(
 
         let array = ndarray::Array3::from_shape_vec((height, width, channels), output_buffer)
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("Shape error: {}", e)))?;
-        let py_array = PyArray3::from_owned_array_bound(py, array);
+        let py_array = PyArray3::from_owned_array(py, array);
         py_results.push(py_array);
     }
 
@@ -206,7 +206,7 @@ pub unsafe fn batch_center_crop_images_zero_copy<'py>(
                 .map_err(|e| {
                     pyo3::exceptions::PyValueError::new_err(format!("Shape error: {}", e))
                 })?;
-        let py_array = PyArray3::from_owned_array_bound(py, array);
+        let py_array = PyArray3::from_owned_array(py, array);
         py_results.push(py_array);
     }
 
@@ -390,10 +390,10 @@ pub fn batch_resize_images_zero_copy<'py>(
     // Convert to PyArray3 and return as Python list
     let py_results: Vec<Bound<'py, PyArray3<u8>>> = results
         .into_iter()
-        .map(|array| PyArray3::from_owned_array_bound(py, array))
+        .map(|array| PyArray3::from_owned_array(py, array))
         .collect();
 
-    Ok(PyList::new_bound(py, py_results).into_any())
+    Ok(PyList::new(py, py_results)?.into_any())
 }
 
 /// Ultra-fast OpenCV-powered resize using zero-copy Mat headers
@@ -552,7 +552,7 @@ fn resize_single_image_direct<'py>(
     })?;
 
     // DIRECT return - no Vec wrapper overhead!
-    Ok(PyArray3::from_owned_array_bound(py, result))
+    Ok(PyArray3::from_owned_array(py, result))
 }
 
 #[cfg(not(feature = "opencv"))]
@@ -578,12 +578,12 @@ fn is_tuple_or_list_of_two(obj: &Bound<PyAny>) -> bool {
     use pyo3::types::{PyList, PyTuple};
 
     // Check if it's a tuple of length 2
-    if let Ok(tuple) = obj.downcast::<PyTuple>() {
+    if let Ok(tuple) = obj.cast::<PyTuple>() {
         return tuple.len() == 2;
     }
 
     // Check if it's a list of length 2 containing numbers (not nested lists)
-    if let Ok(list) = obj.downcast::<PyList>() {
+    if let Ok(list) = obj.cast::<PyList>() {
         if list.len() == 2 {
             // Check if first element is a number (not a nested list/tuple)
             if let Ok(first) = list.get_item(0) {
@@ -616,7 +616,7 @@ impl ResizeIterator {
         // Transfer the completed allocation directly into the ndarray instead
         // of cloning the full resized image during iteration.
         match ndarray::Array3::from_shape_vec((height, width, channels), buffer) {
-            Ok(array) => Some(PyArray3::from_owned_array_bound(py, array)),
+            Ok(array) => Some(PyArray3::from_owned_array(py, array)),
             Err(_) => None, // Malformed buffer; end iteration (StopIteration)
         }
     }
@@ -872,7 +872,7 @@ pub fn batch_crop_images<'py>(
         let img_view = image.as_array();
         match crop_image_array(&img_view, x, y, width, height) {
             Ok(cropped) => {
-                let py_array = PyArray3::from_owned_array_bound(py, cropped);
+                let py_array = PyArray3::from_owned_array(py, cropped);
                 py_results.push(py_array);
             }
             Err(e) => {
@@ -905,7 +905,7 @@ pub fn batch_center_crop_images<'py>(
         let img_view = image.as_array();
         match crate::cropping::center_crop_image_array(&img_view, target_width, target_height) {
             Ok(cropped) => {
-                let py_array = PyArray3::from_owned_array_bound(py, cropped);
+                let py_array = PyArray3::from_owned_array(py, cropped);
                 py_results.push(py_array);
             }
             Err(e) => {
@@ -932,7 +932,7 @@ pub fn batch_random_crop_images<'py>(
         let img_view = image.as_array();
         match random_crop_image_array(&img_view, target_width, target_height) {
             Ok(cropped) => {
-                let py_array = PyArray3::from_owned_array_bound(py, cropped);
+                let py_array = PyArray3::from_owned_array(py, cropped);
                 py_results.push(py_array);
             }
             Err(e) => {
@@ -958,7 +958,7 @@ pub fn batch_calculate_luminance(
 
     let image_views: Vec<_> = images.iter().map(|image| image.as_array()).collect();
 
-    Ok(py.allow_threads(|| {
+    Ok(py.detach(|| {
         image_views
             .par_iter()
             .map(crate::luminance::calculate_luminance_array_sequential)
@@ -984,7 +984,7 @@ pub fn rgb_to_rgba_optimized<'py>(
     let rgba_array = ndarray::Array3::from_shape_vec((height, width, 4), rgba_data)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("Shape error: {}", e)))?;
 
-    let py_array = PyArray3::from_owned_array_bound(py, rgba_array);
+    let py_array = PyArray3::from_owned_array(py, rgba_array);
     Ok((py_array, metrics.throughput_mpixels_per_sec))
 }
 
@@ -1013,7 +1013,7 @@ pub fn rgba_to_rgb_optimized<'py>(
     let rgb_array = ndarray::Array3::from_shape_vec((height, width, 3), rgb_data)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("Shape error: {}", e)))?;
 
-    let py_array = PyArray3::from_owned_array_bound(py, rgb_array);
+    let py_array = PyArray3::from_owned_array(py, rgb_array);
     Ok((py_array, metrics.throughput_mpixels_per_sec))
 }
 
@@ -1057,7 +1057,7 @@ pub fn batch_resize_images<'py>(
         Ok(resized_images) => {
             let py_results: Vec<_> = resized_images
                 .into_iter()
-                .map(|resized| PyArray3::from_owned_array_bound(py, resized))
+                .map(|resized| PyArray3::from_owned_array(py, resized))
                 .collect();
             Ok(py_results)
         }
@@ -1095,7 +1095,7 @@ pub fn batch_resize_videos<'py>(
         Ok(resized_videos) => {
             let py_results: Vec<_> = resized_videos
                 .into_iter()
-                .map(|resized| PyArray4::from_owned_array_bound(py, resized))
+                .map(|resized| PyArray4::from_owned_array(py, resized))
                 .collect();
             Ok(py_results)
         }
@@ -1134,7 +1134,7 @@ pub fn resize_bilinear_opencv<'py>(
 
     match resize_bilinear_opencv(&image_array, target_width, target_height) {
         Ok(resized) => {
-            let py_array = PyArray3::from_owned_array_bound(py, resized);
+            let py_array = PyArray3::from_owned_array(py, resized);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1158,7 +1158,7 @@ pub fn resize_lanczos4_opencv<'py>(
 
     match resize_lanczos4_opencv(&image_array, target_width, target_height) {
         Ok(resized) => {
-            let py_array = PyArray3::from_owned_array_bound(py, resized);
+            let py_array = PyArray3::from_owned_array(py, resized);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1218,11 +1218,11 @@ pub fn imdecode_py<'py>(
         }
     };
 
-    let decoded = py.allow_threads(move || imdecode(&buf, imread_flags));
+    let decoded = py.detach(move || imdecode(&buf, imread_flags));
 
     match decoded {
         Ok(image) => {
-            let py_array = PyArray3::from_owned_array_bound(py, image);
+            let py_array = PyArray3::from_owned_array(py, image);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1258,7 +1258,7 @@ pub fn cvt_color_py<'py>(
     let src_array = src.as_array();
     match cvt_color(&src_array, color_code) {
         Ok(converted) => {
-            let py_array = PyArray3::from_owned_array_bound(py, converted);
+            let py_array = PyArray3::from_owned_array(py, converted);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1281,7 +1281,7 @@ pub fn canny_py<'py>(
     let image_array = image.as_array();
     match canny(&image_array, threshold1, threshold2) {
         Ok(edges) => {
-            let py_array = PyArray3::from_owned_array_bound(py, edges);
+            let py_array = PyArray3::from_owned_array(py, edges);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1317,7 +1317,7 @@ pub fn resize_py<'py>(
     let src_array = src.as_array();
     match resize(&src_array, dsize, interp) {
         Ok(resized) => {
-            let py_array = PyArray3::from_owned_array_bound(py, resized);
+            let py_array = PyArray3::from_owned_array(py, resized);
             Ok(py_array)
         }
         Err(e) => Err(pyo3::exceptions::PyRuntimeError::new_err(format!(
@@ -1328,7 +1328,7 @@ pub fn resize_py<'py>(
 }
 
 #[cfg(feature = "python-bindings")]
-#[pyclass]
+#[pyclass(unsendable)]
 pub struct PyVideoCapture {
     inner: VideoCapture,
     temp_path: Option<TempPath>,
@@ -1419,7 +1419,7 @@ impl PyVideoCapture {
     fn read<'py>(&mut self, py: Python<'py>) -> PyResult<(bool, Option<Bound<'py, PyArray3<u8>>>)> {
         let (ret, frame) = self.inner.read();
         if let Some(frame_data) = frame {
-            let py_array = PyArray3::from_owned_array_bound(py, frame_data);
+            let py_array = PyArray3::from_owned_array(py, frame_data);
             Ok((ret, Some(py_array)))
         } else {
             Ok((ret, None))
@@ -1639,7 +1639,7 @@ impl PyBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }
@@ -1679,7 +1679,7 @@ impl PyBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }
@@ -1704,7 +1704,7 @@ impl PyBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }
@@ -1782,7 +1782,7 @@ impl PyBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }
@@ -1903,7 +1903,7 @@ impl PyTrueBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }
@@ -1939,7 +1939,7 @@ impl PyTrueBatchProcessor {
             Ok(results) => {
                 let py_results: Vec<_> = results
                     .into_iter()
-                    .map(|result| PyArray3::from_owned_array_bound(py, result))
+                    .map(|result| PyArray3::from_owned_array(py, result))
                     .collect();
                 Ok(py_results)
             }

trainingsample-0.3.2/tests/coverage_tests.rs

@@ -0,0 +1,427 @@
+use image::{DynamicImage, ImageFormat, RgbImage};
+use ndarray::{Array3, Array4};
+use std::io::Cursor;
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+use trainingsample::{
+    batch_load_images, fourcc, load_and_decode_image, load_image_from_path, BatchProcessor,
+    CascadeClassifier, ColorConversion, ColorConversionCode, ImreadFlags, OptimizedBatchProcessor,
+    ResizeInterpolation, TrueBatchProcessor, VideoCapture, VideoCaptureProperties, VideoOperation,
+    VideoWriter,
+};
+
+#[cfg(feature = "simd")]
+use trainingsample::{
+    rgb_to_rgba_optimized, rgb_to_rgba_scalar, rgba_to_rgb_optimized, rgba_to_rgb_scalar,
+    FormatConversionMetrics,
+};
+
+fn sample_rgb(height: usize, width: usize) -> Array3<u8> {
+    Array3::from_shape_fn((height, width, 3), |(y, x, channel)| {
+        ((y * 37 + x * 19 + channel * 71) % 256) as u8
+    })
+}
+
+fn encode_png(image: &Array3<u8>) -> Vec<u8> {
+    let (height, width, channels) = image.dim();
+    assert_eq!(channels, 3);
+
+    let rgb = RgbImage::from_raw(width as u32, height as u32, image.iter().copied().collect())
+        .expect("test image dimensions should match its data");
+    let mut encoded = Cursor::new(Vec::new());
+    DynamicImage::ImageRgb8(rgb)
+        .write_to(&mut encoded, ImageFormat::Png)
+        .expect("test image should encode");
+    encoded.into_inner()
+}
+
+fn temporary_path(extension: &str) -> PathBuf {
+    let nonce = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("system clock should follow the Unix epoch")
+        .as_nanos();
+    std::env::temp_dir().join(format!(
+        "trainingsample-coverage-{}-{nonce}.{extension}",
+        std::process::id()
+    ))
+}
+
+struct TemporaryImage(PathBuf);
+
+impl TemporaryImage {
+    fn create(contents: &[u8]) -> Self {
+        let path = temporary_path("png");
+        std::fs::write(&path, contents).expect("temporary image should be writable");
+        Self(path)
+    }
+}
+
+impl Drop for TemporaryImage {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(&self.0);
+    }
+}
+
+#[test]
+#[cfg(feature = "simd")]
+fn format_conversion_implementations_preserve_pixels() {
+    let image = sample_rgb(2, 8);
+
+    let (scalar_rgba, scalar_metrics) = rgb_to_rgba_scalar(&image.view(), 173);
+    let (optimized_rgba, optimized_metrics) = rgb_to_rgba_optimized(&image.view(), 173);
+    assert_eq!(optimized_rgba, scalar_rgba);
+    assert!(scalar_rgba.chunks_exact(4).all(|pixel| pixel[3] == 173));
+    assert_eq!(scalar_metrics.pixels_processed, 16);
+    assert_eq!(scalar_metrics.simd_width, 1);
+    assert_eq!(scalar_metrics.implementation, "scalar_rgb_to_rgba");
+    assert_eq!(optimized_metrics.pixels_processed, 16);
+    assert_eq!(optimized_metrics.simd_width, 8);
+    assert_eq!(optimized_metrics.implementation, "simd_rgb_to_rgba");
+
+    let (scalar_rgb, _) = rgba_to_rgb_scalar(&scalar_rgba, 8, 2);
+    let (optimized_rgb, optimized_reverse_metrics) = rgba_to_rgb_optimized(&scalar_rgba, 8, 2);
+    assert_eq!(optimized_rgb, scalar_rgb);
+    assert_eq!(scalar_rgb, image.iter().copied().collect::<Vec<_>>());
+    assert_eq!(optimized_reverse_metrics.pixels_processed, 16);
+
+    let metrics = FormatConversionMetrics::new(1_000_000, 1_000_000_000, 4, "test");
+    assert_eq!(metrics.throughput_mpixels_per_sec, 1.0);
+    assert_eq!(metrics.simd_width, 4);
+}
+
+#[test]
+fn loading_functions_return_raw_and_decoded_images() {
+    let image = sample_rgb(3, 5);
+    let encoded = encode_png(&image);
+    let temporary = TemporaryImage::create(&encoded);
+    let path = temporary
+        .0
+        .to_str()
+        .expect("temporary test path should be valid UTF-8");
+
+    assert_eq!(load_image_from_path(path).unwrap(), encoded);
+    assert_eq!(
+        load_and_decode_image(path).unwrap().to_rgb8().dimensions(),
+        (5, 3)
+    );
+
+    let missing = temporary.0.with_extension("missing");
+    let results = batch_load_images(&[temporary.0.as_path(), missing.as_path()]);
+    assert_eq!(results.len(), 2);
+    assert_eq!(results[0].as_ref().unwrap(), &encoded);
+    assert!(results[1].is_err());
+}
+
+#[test]
+fn batch_processor_covers_sequential_pipelines_and_validation() {
+    let processor = BatchProcessor::with_config(false, 2);
+    let image = sample_rgb(8, 8);
+    let second = sample_rgb(6, 10);
+    let views = [image.view(), second.view()];
+    let encoded = encode_png(&image);
+
+    let decoded = processor.batch_imdecode(&[encoded.as_slice()], ImreadFlags::ImreadColor);
+    assert_eq!(decoded[0].as_ref().unwrap().dim(), image.dim());
+    assert!(processor.batch_imdecode(&[b"not an image"], ImreadFlags::ImreadColor)[0].is_err());
+
+    assert!(processor
+        .batch_cvt_color(&[], ColorConversionCode::ColorBgr2Rgb)
+        .unwrap()
+        .is_empty());
+    let swapped = processor
+        .batch_cvt_color(&views, ColorConversionCode::ColorBgr2Rgb)
+        .unwrap();
+    assert_eq!(swapped[0][[0, 0, 0]], image[[0, 0, 2]]);
+    assert_eq!(swapped[0][[0, 0, 2]], image[[0, 0, 0]]);
+
+    assert!(processor
+        .batch_resize(&views, &[(4, 4)], ResizeInterpolation::InterLinear)
+        .is_err());
+    assert!(processor
+        .batch_resize(&[], &[], ResizeInterpolation::InterLinear)
+        .unwrap()
+        .is_empty());
+    let resized = processor
+        .batch_resize(&views, &[(4, 4), (5, 3)], ResizeInterpolation::InterNearest)
+        .unwrap();
+    assert_eq!(resized[0].dim(), (4, 4, 3));
+    assert_eq!(resized[1].dim(), (3, 5, 3));
+
+    assert!(processor.batch_canny(&[], 25.0, 50.0).unwrap().is_empty());
+    let edges = processor.batch_canny(&views, 25.0, 50.0).unwrap();
+    assert_eq!(edges[0].dim(), (8, 8, 1));
+    assert_eq!(edges[1].dim(), (6, 10, 1));
+
+    assert!(processor
+        .batch_preprocess_pipeline(
+            &[encoded.as_slice()],
+            &[],
+            None,
+            ImreadFlags::ImreadColor,
+            ResizeInterpolation::InterLinear,
+        )
+        .is_err());
+    let preprocessed = processor
+        .batch_preprocess_pipeline(
+            &[encoded.as_slice()],
+            &[(5, 5)],
+            Some(ColorConversionCode::ColorRgb2Gray),
+            ImreadFlags::ImreadColor,
+            ResizeInterpolation::InterCubic,
+        )
+        .unwrap();
+    assert_eq!(preprocessed[0].dim(), (5, 5, 1));
+
+    let detections = processor
+        .batch_face_detection_pipeline(&views, 1.1, 3)
+        .unwrap();
+    assert_eq!(detections, vec![Vec::new(), Vec::new()]);
+}
+
+#[test]
+fn batch_processor_covers_parallel_and_video_paths() {
+    let processor = BatchProcessor::with_config(true, 1);
+    let images = [sample_rgb(5, 6), sample_rgb(5, 6), sample_rgb(5, 6)];
+    let views: Vec<_> = images.iter().map(|image| image.view()).collect();
+    let buffers: Vec<_> = images.iter().map(encode_png).collect();
+    let buffer_views: Vec<_> = buffers.iter().map(Vec::as_slice).collect();
+
+    assert_eq!(
+        processor
+            .batch_imdecode(&buffer_views, ImreadFlags::ImreadColor)
+            .len(),
+        3
+    );
+    assert_eq!(
+        processor
+            .batch_cvt_color(&views, ColorConversionCode::ColorRgb2Gray)
+            .unwrap()
+            .len(),
+        3
+    );
+    let resized = processor
+        .batch_resize(
+            &views,
+            &[(12, 10), (6, 5), (12, 10)],
+            ResizeInterpolation::InterLanczos4,
+        )
+        .unwrap();
+    assert_eq!(resized[0].dim(), (10, 12, 3));
+    assert_eq!(resized[1].dim(), (5, 6, 3));
+    assert_eq!(processor.batch_canny(&views, 10.0, 20.0).unwrap().len(), 3);
+
+    let video = Array4::from_shape_fn((2, 5, 6, 3), |(frame, y, x, channel)| {
+        ((frame * 43 + y * 17 + x * 11 + channel * 67) % 256) as u8
+    });
+    let processed = processor
+        .batch_video_frame_processing(
+            &[video.view()],
+            (12, 10),
+            &[
+                VideoOperation::Resize(ResizeInterpolation::InterLinear),
+                VideoOperation::ColorConvert(ColorConversionCode::ColorBgr2Rgb),
+                VideoOperation::EdgeDetection(10.0, 20.0),
+            ],
+        )
+        .unwrap();
+    assert_eq!(processed[0].dim(), (2, 10, 12, 1));
+
+    let empty_video = Array4::<u8>::zeros((0, 5, 6, 3));
+    let empty_processed = processor
+        .batch_video_frame_processing(&[empty_video.view()], (4, 3), &[])
+        .unwrap();
+    assert_eq!(empty_processed[0].dim(), empty_video.dim());
+}
+
+#[test]
+fn optimized_batch_processor_covers_conversion_and_resize_paths() {
+    let sequential = OptimizedBatchProcessor {
+        use_parallel: false,
+        chunk_size: 8,
+    };
+    let image = sample_rgb(2, 4);
+    let views = [image.view()];
+
+    assert!(sequential
+        .batch_cvt_color_optimized(&[], ColorConversionCode::ColorBgr2Rgb)
+        .unwrap()
+        .is_empty());
+    let swapped = sequential
+        .batch_cvt_color_optimized(&views, ColorConversionCode::ColorBgr2Rgb)
+        .unwrap();
+    assert_eq!(swapped[0][[1, 3, 0]], image[[1, 3, 2]]);
+    assert_eq!(swapped[0][[1, 3, 2]], image[[1, 3, 0]]);
+
+    let grayscale = sequential
+        .batch_cvt_color_optimized(&views, ColorConversionCode::ColorRgb2Gray)
+        .unwrap();
+    assert_eq!(grayscale[0].dim(), (2, 4, 1));
+
+    let single_channel = Array3::from_shape_vec((1, 2, 1), vec![25, 200]).unwrap();
+    let expanded = sequential
+        .batch_cvt_color_optimized(&[single_channel.view()], ColorConversionCode::ColorGray2Rgb)
+        .unwrap();
+    assert_eq!(expanded[0].dim(), (1, 2, 3));
+    assert_eq!(expanded[0][[0, 1, 0]], 200);
+    assert!(sequential
+        .batch_cvt_color_optimized(&[single_channel.view()], ColorConversionCode::ColorRgb2Gray,)
+        .is_err());
+
+    assert!(sequential
+        .batch_resize_optimized(&views, &[], ResizeInterpolation::InterLinear)
+        .is_err());
+    let resized = sequential
+        .batch_resize_optimized(&views, &[(2, 1)], ResizeInterpolation::InterNearest)
+        .unwrap();
+    assert_eq!(resized[0].dim(), (1, 2, 3));
+
+    let parallel = OptimizedBatchProcessor {
+        use_parallel: true,
+        chunk_size: 1,
+    };
+    let parallel_images = [sample_rgb(4, 4), sample_rgb(4, 4), sample_rgb(4, 4)];
+    let parallel_views: Vec<_> = parallel_images.iter().map(|image| image.view()).collect();
+    assert_eq!(
+        parallel
+            .batch_cvt_color_optimized(&parallel_views, ColorConversionCode::ColorRgb2Gray)
+            .unwrap()
+            .len(),
+        3
+    );
+    let parallel_resized = parallel
+        .batch_resize_optimized(
+            &parallel_views,
+            &[(2, 2), (3, 3), (2, 2)],
+            ResizeInterpolation::InterCubic,
+        )
+        .unwrap();
+    assert_eq!(parallel_resized[0].dim(), (2, 2, 3));
+    assert_eq!(parallel_resized[1].dim(), (3, 3, 3));
+}
+
+#[test]
+fn true_batch_processor_covers_resize_color_and_luminance_paths() {
+    let sequential = TrueBatchProcessor {
+        use_parallel: false,
+        chunk_size: 8,
+        simd_threshold: 4,
+    };
+    let image = sample_rgb(4, 5);
+    let views = [image.view()];
+
+    assert!(sequential
+        .true_batch_resize(&[], &[], ResizeInterpolation::InterLinear)
+        .unwrap()
+        .is_empty());
+    #[cfg(feature = "opencv")]
+    assert!(sequential
+        .true_batch_resize(&views, &[], ResizeInterpolation::InterLinear)
+        .is_err());
+
+    for interpolation in [
+        ResizeInterpolation::InterNearest,
+        ResizeInterpolation::InterLinear,
+        ResizeInterpolation::InterCubic,
+        ResizeInterpolation::InterLanczos4,
+    ] {
+        let resized = sequential
+            .true_batch_resize(&views, &[(3, 2)], interpolation)
+            .unwrap();
+        assert_eq!(resized[0].dim(), (2, 3, 3));
+    }
+
+    assert!(sequential
+        .true_batch_cvt_color(&[], ColorConversion::BgrToRgb)
+        .unwrap()
+        .is_empty());
+    let swapped = sequential
+        .true_batch_cvt_color(&views, ColorConversion::BgrToRgb)
+        .unwrap();
+    assert_eq!(swapped[0][[0, 0, 0]], image[[0, 0, 2]]);
+    assert_eq!(swapped[0][[0, 0, 2]], image[[0, 0, 0]]);
+    assert_eq!(
+        sequential
+            .true_batch_cvt_color(&views, ColorConversion::RgbToBgr)
+            .unwrap()[0]
+            .dim(),
+        image.dim()
+    );
+    assert_eq!(
+        sequential
+            .true_batch_cvt_color(&views, ColorConversion::RgbToGray)
+            .unwrap()[0]
+            .dim(),
+        (4, 5, 1)
+    );
+    assert!(sequential
+        .true_batch_cvt_color(&views, ColorConversion::GrayToRgb)
+        .is_err());
+
+    let luminance = sequential.strided_luminance(&views, 0).unwrap();
+    assert_eq!(luminance.len(), 1);
+    assert!((0.0..=255.0).contains(&luminance[0]));
+    let empty_image = Array3::<u8>::zeros((0, 0, 3));
+    assert_eq!(
+        sequential
+            .strided_luminance(&[empty_image.view()], 3)
+            .unwrap(),
+        vec![0.0]
+    );
+    let invalid_image = Array3::<u8>::zeros((2, 2, 1));
+    assert!(sequential
+        .strided_luminance(&[invalid_image.view()], 1)
+        .is_err());
+
+    let parallel = TrueBatchProcessor {
+        use_parallel: true,
+        chunk_size: 1,
+        simd_threshold: 1,
+    };
+    let parallel_images = [sample_rgb(4, 5), sample_rgb(4, 5)];
+    let parallel_views: Vec<_> = parallel_images.iter().map(|image| image.view()).collect();
+    assert_eq!(
+        parallel
+            .strided_luminance(&parallel_views, 2)
+            .unwrap()
+            .len(),
+        2
+    );
+}
+
+#[test]
+fn compatibility_objects_cover_success_and_error_states() {
+    assert_eq!(fourcc('M', 'J', 'P', 'G'), "MJPG");
+
+    let missing_video = temporary_path("avi");
+    let mut capture = VideoCapture::new(missing_video.to_str().unwrap()).unwrap();
+    assert!(!capture.is_opened());
+    assert_eq!(capture.get(VideoCaptureProperties::CapPropFps), 0.0);
+    assert_eq!(capture.get(VideoCaptureProperties::CapPropFrameWidth), 0.0);
+    assert_eq!(capture.get(VideoCaptureProperties::CapPropFrameHeight), 0.0);
+    assert_eq!(capture.get(VideoCaptureProperties::CapPropFrameCount), 0.0);
+    assert_eq!(capture.read(), (false, None));
+    capture.release();
+
+    let image = sample_rgb(2, 3);
+    let mut writer = VideoWriter::new("unused.avi", "MJPG", 24.0, (3, 2)).unwrap();
+    assert!(writer.is_opened());
+    writer.write(&image.view()).unwrap();
+    assert!(writer
+        .write(&Array3::<u8>::zeros((2, 3, 1)).view())
+        .is_err());
+    assert!(writer
+        .write(&Array3::<u8>::zeros((3, 2, 3)).view())
+        .is_err());
+    writer.release().unwrap();
+    writer.release().unwrap();
+    assert!(!writer.is_opened());
+    assert!(writer.write(&image.view()).is_err());
+
+    let missing_cascade = temporary_path("xml");
+    let cascade = CascadeClassifier::new(missing_cascade.to_str().unwrap()).unwrap();
+    assert!(cascade.empty());
+    assert!(cascade
+        .detect_multi_scale(&image.view(), 1.1, 3)
+        .unwrap()
+        .is_empty());
+}