prpy 0.2.7__tar.gz → 0.2.8__tar.gz

{prpy-0.2.7 → prpy-0.2.8}/MANIFEST.in

@@ -4,4 +4,6 @@ recursive-include prpy/tensorflow *
 recursive-include prpy/torch *
 recursive-include prpy/ffmpeg *
 recursive-include tests *
+global-exclude .DS_Store
 prune **/__pycache__ 
+prune .github/workflows

{prpy-0.2.7 → prpy-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prpy
-Version: 0.2.7
+Version: 0.2.8
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License
@@ -35,6 +35,7 @@ Requires-Dist: torch==2.1.0; extra == "torch"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: flake8; extra == "test"
+Requires-Dist: psutil; extra == "test"
 
 
 # prpy

{prpy-0.2.7 → prpy-0.2.8}/prpy/numpy/image_ops.c

@@ -18,8 +18,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+
 #include <Python.h>
 #include <numpy/arrayobject.h>
+#include <stdlib.h>
 
 #define DIV_ROUND_CLOSEST(n, d) ((((n) < 0) == ((d) < 0)) ? (((n) + (d)/2)/(d)) : (((n) - (d)/2)/(d)))
 
@@ -50,16 +53,24 @@ resample_bilinear_op(PyObject* self, PyObject* args) {
 
   // Get the dimensions of the input array
   npy_intp* dims = PyArray_DIMS(input_array);
-  int n_frames = dims[0];
-  int height = dims[1];
-  int width = dims[2];
+  int n_frames = (int)dims[0];
+  int height = (int)dims[1];
+  int width = (int)dims[2];
 
   // Get the strides
   npy_intp* input_strides = PyArray_STRIDES(input_array);
 
+  // Allocate memory for the positions and weights
+  int* pos_flat = malloc(new_width * new_height * 2 * sizeof(int));
+  float* weights_flat = malloc(new_width * new_height * 2 * 2 * sizeof(float));
+  if (!pos_flat || !weights_flat) {
+    PyErr_SetString(PyExc_MemoryError, "Unable to allocate memory for position and weights arrays");
+    free(pos_flat);
+    free(weights_flat);
+    return NULL;
+  }
+
   // Precompute the positions and weights
-  int pos[new_width][new_height][2];
-  float weights[new_width][new_height][2][2];
   for (int y = 0; y < new_height; ++y) {
     for (int x = 0; x < new_width; ++x) {
       // Determine the position of the current pixel in the input image
@@ -74,13 +85,14 @@ resample_bilinear_op(PyObject* self, PyObject* args) {
       float dx1 = 1.0f - dx;
       float dy1 = 1.0f - dy;
       // Store the positions
-      pos[x][y][0] = x0;
-      pos[x][y][1] = y0;
+      int flat_idx = (x * new_height + y) * 2; 
+      pos_flat[flat_idx + 0] = x0;
+      pos_flat[flat_idx + 1] = y0;
       // Store the weights
-      weights[x][y][0][0] = (int)(dx1 * dy1 * 256.0f);
-      weights[x][y][0][1] = (int)(dx  * dy1 * 256.0f);
-      weights[x][y][1][0] = (int)(dx1 * dy  * 256.0f);
-      weights[x][y][1][1] = (int)(dx  * dy  * 256.0f);
+      weights_flat[(flat_idx + 0) * 2 + 0] = dx1 * dy1 * 256.0f;
+      weights_flat[(flat_idx + 0) * 2 + 1] = dx  * dy1 * 256.0f;
+      weights_flat[(flat_idx + 1) * 2 + 0] = dx1 * dy  * 256.0f;
+      weights_flat[(flat_idx + 1) * 2 + 1] = dx  * dy  * 256.0f;
     }
   }
 
@@ -103,29 +115,40 @@ resample_bilinear_op(PyObject* self, PyObject* args) {
     // Resize the frame using bilinear resampling
     for (int y = 0; y < new_height; ++y) {
       for (int x = 0; x < new_width; ++x) {
-        unsigned char* p1 = current_frame + pos[x][y][1] * input_strides[1] + pos[x][y][0] * input_strides[2];
+        // Get position coordinates
+        int pos_idx = (x * new_height + y) * 2;
+        int x0 = pos_flat[pos_idx + 0];
+        int y0 = pos_flat[pos_idx + 1];
+        
+        // Get weights
+        int weights_idx = ((x * new_height + y) * 2) * 2;
+        float w00 = weights_flat[weights_idx + 0];
+        float w01 = weights_flat[weights_idx + 1];
+        float w10 = weights_flat[weights_idx + 2];
+        float w11 = weights_flat[weights_idx + 3];
+
+        // Access pixels
+        unsigned char* p1 = current_frame + y0 * input_strides[1] + x0 * input_strides[2];
         unsigned char* p2 = p1 + input_strides[2];
         unsigned char* p3 = p1 + input_strides[1];
         unsigned char* p4 = p3 + input_strides[2];
 
         // Make sure that p2 and p4 are within bounds
-        if (pos[x][y][0] + 1 >= width) {
+        if (x0 + 1 >= width) {
           p2 = p1;
           p4 = p3;
         }
         // Make sure that p3 and p4 are within bounds
-        if (pos[x][y][1] + 1 >= height) {
+        if (y0 + 1 >= height) {
           p3 = p1;
           p4 = p2;
         }
         
         // Calculate the weighted sum of pixels (for each color channel)
-        int outr = p1[0] * weights[x][y][0][0] + p2[0] * weights[x][y][0][1] + 
-                   p3[0] * weights[x][y][1][0] + p4[0] * weights[x][y][1][1];
-        int outg = p1[1] * weights[x][y][0][0] + p2[1] * weights[x][y][0][1] + 
-                   p3[1] * weights[x][y][1][0] + p4[1] * weights[x][y][1][1];
-        int outb = p1[2] * weights[x][y][0][0] + p2[2] * weights[x][y][0][1] + 
-                   p3[2] * weights[x][y][1][0] + p4[2] * weights[x][y][1][1];
+        int outr = p1[0] * w00 + p2[0] * w01 + p3[0] * w10 + p4[0] * w11;
+        int outg = p1[1] * w00 + p2[1] * w01 + p3[1] * w10 + p4[1] * w11;
+        int outb = p1[2] * w00 + p2[2] * w01 + p3[2] * w10 + p4[2] * w11;
+
         // Save
         int idx = i * new_height * new_width * 3 + y * new_width * 3 + x * 3;
         output_data[idx + 0] = (unsigned char)(outr >> 8);
@@ -135,6 +158,10 @@ resample_bilinear_op(PyObject* self, PyObject* args) {
     }
   }
 
+  // Free allocated memory
+  free(pos_flat);
+  free(weights_flat);
+
   return PyArray_Return(output_array_np);
 }
 
@@ -165,9 +192,9 @@ resample_box_op(PyObject* self, PyObject* args) {
 
   // Get the dimensions of the input array
   npy_intp* dims = PyArray_DIMS(input_array);
-  int n_frames = dims[0];
-  int height = dims[1];
-  int width = dims[2];
+  int n_frames = (int)dims[0];
+  int height = (int)dims[1];
+  int width = (int)dims[2];
 
   // Make sure that we are downsampling
   if (height / new_height < 2 || width / new_width < 2) {
@@ -183,18 +210,32 @@ resample_box_op(PyObject* self, PyObject* args) {
   PyArrayObject* output_array_np = (PyArrayObject*)PyArray_EMPTY(4, output_dims, NPY_UINT8, 0);
   if (output_array_np == NULL) {
     Py_DECREF(output_array_np);
+    PyErr_SetString(PyExc_MemoryError, "Unable to allocate output array");
     return NULL;
   }
 
   // Get a pointer to the output data
   unsigned char* output_data = (unsigned char*)PyArray_DATA(output_array_np);
 
+  // Allocate memory for start and end indices for rows and columns and num_pixels
+  int* start_x = (int*)malloc(new_width * sizeof(int));
+  int* end_x = (int*)malloc(new_width * sizeof(int));
+  int* start_y = (int*)malloc(new_height * sizeof(int));
+  int* end_y = (int*)malloc(new_height * sizeof(int));
+  int* num_pixels_flat = malloc(new_width * new_height * sizeof(int));
+  if (!start_x || !end_x || !start_y || !end_y || !num_pixels_flat) {
+    // Clean up allocated memory before returning error
+    free(start_x);
+    free(end_x);
+    free(start_y);
+    free(end_y);
+    free(num_pixels_flat);
+    PyErr_SetString(PyExc_MemoryError, "Unable to allocate memory for indices");
+    Py_DECREF(output_array_np);
+    return NULL;
+  }
+
   // Precompute start and end indices for rows and columns and num_pixels
-  int start_x[new_width];
-  int end_x[new_width];
-  int start_y[new_height];
-  int end_y[new_height];
-  int num_pixels_[new_width][new_height];
   for (int x = 0; x < new_width; ++x) {
     start_x[x] = DIV_ROUND_CLOSEST(x * width, new_width);
     end_x[x] = DIV_ROUND_CLOSEST((x + 1) * width, new_width);
@@ -203,7 +244,7 @@ resample_box_op(PyObject* self, PyObject* args) {
     start_y[y] = DIV_ROUND_CLOSEST(y * height, new_height);
     end_y[y] = DIV_ROUND_CLOSEST((y + 1) * height, new_height);
     for (int x = 0; x < new_width; ++x) {
-      num_pixels_[x][y] = (end_y[y] - start_y[y]) * (end_x[x] - start_x[x]);
+      num_pixels_flat[y * new_width + x] = (end_y[y] - start_y[y]) * (end_x[x] - start_x[x]);
     }
   }
 
@@ -216,6 +257,7 @@ resample_box_op(PyObject* self, PyObject* args) {
       for (int x = 0; x < new_width; ++x) {
         // Compute the mean of pixels in the input image block
         int sum_r = 0, sum_g = 0, sum_b = 0;
+        int num_pixels = num_pixels_flat[y * new_width + x];
         for (int src_y = start_y[y]; src_y < end_y[y]; ++src_y) {
           for (int src_x = start_x[x]; src_x < end_x[x]; ++src_x) {
             unsigned char* pixel = current_frame + src_y * input_strides[1] + src_x * input_strides[2];
@@ -225,7 +267,6 @@ resample_box_op(PyObject* self, PyObject* args) {
           }
         }
         // Calculate the average value of the pixels
-        int num_pixels = num_pixels_[x][y];
         unsigned char avg_r = (unsigned char)(sum_r / num_pixels);
         unsigned char avg_g = (unsigned char)(sum_g / num_pixels);
         unsigned char avg_b = (unsigned char)(sum_b / num_pixels);
@@ -238,6 +279,13 @@ resample_box_op(PyObject* self, PyObject* args) {
     }
   }
 
+  // Free allocated memory
+  free(start_x);
+  free(end_x);
+  free(start_y);
+  free(end_y);
+  free(num_pixels_flat);
+
   return PyArray_Return(output_array_np);
 }
 
@@ -273,7 +321,7 @@ reduce_roi_op(PyObject* self, PyObject* args) {
 
   // Get the dimensions of the input video array
   npy_intp* video_dims = PyArray_DIMS(input_array_video);
-  int n_frames = video_dims[0];
+  int n_frames = (int)video_dims[0];
 
   // Create an output array
   npy_intp output_dims[2] = {n_frames, 3};

{prpy-0.2.7 → prpy-0.2.8}/prpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prpy
-Version: 0.2.7
+Version: 0.2.8
 Summary: Collection of Python utils for signal, image, and video processing
 Author-email: Philipp Rouast <philipp@rouast.com>
 License: MIT License
@@ -35,6 +35,7 @@ Requires-Dist: torch==2.1.0; extra == "torch"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: flake8; extra == "test"
+Requires-Dist: psutil; extra == "test"
 
 
 # prpy

{prpy-0.2.7 → prpy-0.2.8}/prpy.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ MANIFEST.in
 README.md
 pyproject.toml
 setup.py
-.github/workflows/main.yml
 prpy/__init__.py
 prpy/constants.py
 prpy/helpers.py
@@ -17,15 +16,12 @@ prpy/ffmpeg/__init__.py
 prpy/ffmpeg/probe.py
 prpy/ffmpeg/readwrite.py
 prpy/ffmpeg/utils.py
-prpy/numpy/.DS_Store
 prpy/numpy/__init__.py
 prpy/numpy/face.py
 prpy/numpy/image.py
 prpy/numpy/image_ops.c
-prpy/numpy/image_ops.cpython-310-darwin.so
 prpy/numpy/metric.py
 prpy/numpy/signal.py
-prpy/numpy/spam.cpython-310-darwin.so
 prpy/numpy/stride_tricks.py
 prpy/tensorflow/__init__.py
 prpy/tensorflow/image.py
@@ -37,7 +33,6 @@ prpy/tensorflow/optimizer.py
 prpy/tensorflow/signal.py
 prpy/torch/__init__.py
 prpy/torch/model_saver.py
-tests/.DS_Store
 tests/conftest.py
 tests/test_ffmpeg.py
 tests/test_numpy_face.py

{prpy-0.2.7 → prpy-0.2.8}/prpy.egg-info/requires.txt

@@ -22,6 +22,7 @@ numpy
 [test]
 pytest
 flake8
+psutil
 
 [torch]
 torch==2.1.0

{prpy-0.2.7 → prpy-0.2.8}/pyproject.toml

@@ -28,7 +28,7 @@ numpy = ["numpy", "scipy", "Pillow", "opencv-python", "scikit-learn"]
 numpy_min = ["numpy", "scipy", "Pillow"]
 tensorflow = ["tensorflow==2.12.1", "numpy"]
 torch = ["torch==2.1.0"]
-test = ["pytest", "flake8"]
+test = ["pytest", "flake8", "psutil"]
 
 [project.urls]
 Repository = "https://github.com/prouast/prpy.git"

{prpy-0.2.7 → prpy-0.2.8}/tests/test_numpy_image.py

@@ -128,7 +128,7 @@ def test_resample_box_only_downsampling():
                                       (3, [[3, 4, 7, 12], [3, 5, 7, 12], [3, 5, 6, 10]])])
 def test_reduce_roi(scenario):
   n_frames = scenario[0]
-  roi = np.asarray(scenario[1])
+  roi = np.asarray(scenario[1]).astype(np.int64)
   video = np.random.uniform(size=(n_frames, 12, 8, 3), low=0, high=255).astype(np.uint8)
   out = reduce_roi(video=video, roi=roi)
   exp = np.asarray([np.mean(video[i, roi[i,1]:roi[i,3], roi[i,0]:roi[i,2]], axis=(0,1)) for i in range(n_frames)])

{prpy-0.2.7 → prpy-0.2.8}/tests/test_tensorflow.py

@@ -203,7 +203,7 @@ from prpy.tensorflow.model_saver import Candidate, ModelSaver
 
 def test_candidate():
   cand = Candidate(score=0.5, dir='testdir', filename='test')
-  assert cand.filepath == 'testdir/test'
+  assert cand.filepath == os.path.join('testdir', 'test')
   assert cand.score == 0.5
 
 @pytest.mark.parametrize("save_format", ["tf", "h5"])

{prpy-0.2.7 → prpy-0.2.8}/tests/test_torch.py

@@ -33,7 +33,7 @@ import torch
 
 def test_candidate():
   cand = Candidate(score=0.5, dir='testdir', filename='test')
-  assert cand.filepath == 'testdir/test'
+  assert cand.filepath == os.path.join('testdir', 'test')
   assert cand.score == 0.5
 
 @pytest.mark.parametrize("save_optimizer", [False, True])

prpy-0.2.7/.github/workflows/main.yml

@@ -1,40 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-
-jobs:
-  build:
-
-    runs-on: [ubuntu-latest]
-    strategy:
-      matrix:
-        python-version: ["3.8", "3.9", "3.10"]
-
-    steps:
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install ffmpeg
-        uses: Iamshankhadeep/setup-ffmpeg@v1.2
-        with:
-          version: "4.4"
-          token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Checkout prpy
-        uses: actions/checkout@v3
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install prpy and dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install ".[ffmpeg,numpy,tensorflow,torch,test]"
-      - name: Lint with flake8
-        run: |
-          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-      - name: Test with pytest
-        run: |
-          pytest