cv-frames 0.0.0__tar.gz

cv_frames-0.0.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: publish
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write  # Required for OIDC authentication
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+
+    - name: Build package
+      run: python -m build
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        verbose: true

cv_frames-0.0.0/.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: tests
+
+on:
+  push:
+    branches:
+      - "**"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+
+      - name: Install dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install -e .
+
+      - name: Run the tests
+        run: |
+          PYTHONFAULTHANDLER=2 pytest --cov=cvframes --cov-report term-missing tests/
+
+      - name: Run pre-commit checks
+        uses: pre-commit/action@v3.0.1

cv_frames-0.0.0/.gitignore

@@ -0,0 +1,5 @@
+*.egg*
+__pycache__/
+.python-version
+.coverage
+*.mp4

cv_frames-0.0.0/.pre-commit-config.yaml

@@ -0,0 +1,39 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+      - id: check-added-large-files
+        args: ["--maxkb=1000"]
+      - id: check-json
+      - id: check-docstring-first
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        args: ["--settings-path", "pyproject.toml"]
+
+
+  - repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+      - id: black
+        args: ["--config", "pyproject.toml"]
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.921
+    hooks:
+      - id: mypy
+        additional_dependencies: ["types-PyYAML"]
+        args: ["--config-file", "pyproject.toml"]
+
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 4.0.1
+    hooks:
+      - id: flake8
+        # args: ["--config", "pyproject.toml"]
+        args: ["--max-line-length=79"]

cv_frames-0.0.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: cv-frames
+Version: 0.0.0
+Summary: Read frames from OpenCV like humans
+Requires-Dist: opencv-python
+Requires-Dist: numpy

cv_frames-0.0.0/README.md

@@ -0,0 +1 @@
+# Read frames from OpenCV like humans

cv_frames-0.0.0/cv_frames.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: cv-frames
+Version: 0.0.0
+Summary: Read frames from OpenCV like humans
+Requires-Dist: opencv-python
+Requires-Dist: numpy

cv_frames-0.0.0/cv_frames.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+.gitignore
+.pre-commit-config.yaml
+README.md
+pyproject.toml
+requirements.txt
+.github/workflows/publish.yml
+.github/workflows/tests.yml
+cv_frames.egg-info/PKG-INFO
+cv_frames.egg-info/SOURCES.txt
+cv_frames.egg-info/dependency_links.txt
+cv_frames.egg-info/requires.txt
+cv_frames.egg-info/top_level.txt
+cvframes/__init__.py
+cvframes/iterate.py
+tests/test_iterate.py

cv_frames-0.0.0/cv_frames.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cv_frames-0.0.0/cv_frames.egg-info/requires.txt

@@ -0,0 +1,2 @@
+opencv-python
+numpy

cv_frames-0.0.0/cv_frames.egg-info/top_level.txt

@@ -0,0 +1 @@
+cvframes

cv_frames-0.0.0/cvframes/iterate.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from typing import Callable, Generator, Optional, Tuple, TypeVar
+
+import cv2
+import numpy as np
+
+T = TypeVar("T")
+
+
+class IOCapture:
+    def __init__(self, source: str | Path, oname: str | Path = ""):
+        self.icap = cv2.VideoCapture(str(source))
+        self.ocap = (
+            cv2.VideoWriter(
+                str(oname),
+                cv2.VideoWriter_fourcc(*"mp4v"),
+                self.icap.get(cv2.CAP_PROP_FPS),
+                (
+                    int(self.icap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+                    int(self.icap.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+                ),
+            )
+            if oname
+            else None
+        )
+
+    def is_opened(self) -> bool:
+        return self.icap.isOpened()
+
+    def read(self) -> Tuple[bool, np.ndarray]:
+        return self.icap.read()
+
+    def write(self, frame: np.ndarray) -> None:
+        if self.ocap is not None:
+            self.ocap.write(frame)
+
+    def release(self) -> None:
+        self.icap.release()
+        if self.ocap is not None:
+            self.ocap.release()
+
+    def set(self, prop_id: int, value: float) -> None:
+        self.icap.set(prop_id, value)
+
+
+def iterate_generic(
+    ipath: Path,
+    opath: Optional[Path],
+    start_frame: int,
+    stop_frame: int,
+    process_frames: Callable[[np.ndarray], T],
+) -> Generator[tuple[IOCapture, T], None, None]:
+    capture = IOCapture(str(ipath), oname=opath or "")
+    capture.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+    count = start_frame
+
+    if not capture.is_opened():
+        return
+
+    try:
+        while True:
+            ret, frame = capture.read()
+            count += 1
+            if not ret:
+                break
+            if stop_frame > 0 and count >= stop_frame:
+                break
+
+            yield capture, process_frames(frame)
+    finally:
+        capture.release()
+
+
+def iterate(
+    ipath: Path,
+    opath: Optional[Path] = None,
+    start_frame: int = -1,
+    stop_frame: int = -1,
+) -> Generator[tuple[IOCapture, np.ndarray], None, None]:
+    return iterate_generic(
+        ipath,
+        opath,
+        start_frame,
+        stop_frame,
+        lambda frame: frame,
+    )
+
+
+def iterate_sbs(
+    ipath: Path,
+    opath: Optional[Path] = None,
+    start_frame: int = -1,
+    stop_frame: int = -1,
+) -> Generator[Tuple[IOCapture, Tuple[np.ndarray, np.ndarray]], None, None]:
+    def processor(frame: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        _, width, _ = frame.shape
+        mid = width // 2
+        return frame[:, :mid, :], frame[:, mid:, :]
+
+    return iterate_generic(
+        ipath,
+        opath,
+        start_frame,
+        stop_frame,
+        processor,
+    )

cv_frames-0.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[tool.black]
+line-length = 79
+
+[tool.isort]
+profile = "black"
+line_length = 79
+
+[tool.mypy]
+python_version = "3.10"
+strict = false
+ignore_missing_imports = true
+
+[tool.flake8]
+max-line-length = 79
+ignore = [
+    "E203", # Whitespace before ':'
+    "W503", # Line break before binary operator
+]
+
+[tool.pytest.ini_options]
+addopts = "--cov=cvframes --cov-report=term-missing"
+
+[build-system]
+requires = ["setuptools", "wheel", "setuptools_scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# NB: Keep it the same as in PyPI
+name = "cv-frames"
+dynamic = ["version"]
+description = "Read frames from OpenCV like humans"
+dependencies = [
+    "opencv-python",
+    "numpy"
+]
+
+[tool.setuptools]
+packages = ["cvframes"]
+
+[tool.setuptools_scm]
+version_scheme = "post-release"  # Uses Git tags for versioning

cv_frames-0.0.0/requirements.txt

@@ -0,0 +1,3 @@
+pytest
+pytest-coverage
+pre-commit

cv_frames-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cv_frames-0.0.0/tests/test_iterate.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+from typing import Optional
+
+import cv2
+import numpy as np
+import pytest
+
+from cvframes.iterate import iterate, iterate_sbs
+
+
+@pytest.fixture
+def video(tmp_path: Path):
+    opath = tmp_path / "test_video.mp4"
+    ovideo = cv2.VideoWriter(
+        str(opath),
+        cv2.VideoWriter_fourcc(*"mp4v"),
+        30,  # FPS
+        (640, 480),
+    )
+
+    for _ in range(5):
+        ovideo.write(np.zeros((480, 640, 3), dtype=np.uint8))
+    ovideo.release()
+    return opath
+
+
+@pytest.mark.parametrize(
+    "opath",
+    [
+        None,
+        Path("output.mp4"),
+    ],
+)
+def test_iterate(video: Path, opath: Optional[Path]):
+    # sourcery skip: no-loop-in-tests
+    for capture, frame in iterate(video, opath=opath):
+        capture.write(frame)
+        assert frame.shape == (480, 640, 3)
+
+
+@pytest.mark.skip("skipping")
+@pytest.mark.parametrize(
+    "opath",
+    [
+        None,
+        Path("output.mp4"),
+    ],
+)
+def test_iterate_sbs(video: Path, opath: Optional[Path]):
+    # sourcery skip: no-loop-in-tests
+    for capture, (lframe, rframe) in iterate_sbs(
+        Path("input.mp4"), opath=opath
+    ):
+        capture.write(lframe)
+        assert lframe.shape == (480, 320, 3)
+        assert rframe.shape == (480, 320, 3)