cv-frames 0.0.1__tar.gz → 0.0.2__tar.gz

{cv_frames-0.0.1 → cv_frames-0.0.2}/.github/workflows/tests.yml

@@ -32,3 +32,9 @@ jobs:
 
       - name: Run pre-commit checks
         uses: pre-commit/action@v3.0.1
+
+      - name: Check package metadata rendering (twine check)
+        run: |
+          pip install build twine
+          python -m build --sdist --wheel
+          twine check dist/*

{cv_frames-0.0.1 → cv_frames-0.0.2}/.gitignore

@@ -3,3 +3,4 @@ __pycache__/
 .python-version
 .coverage
 *.mp4
+.vscode

cv_frames-0.0.2/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: cv-frames
+Version: 0.0.2
+Summary: Read frames from OpenCV like humans
+Description-Content-Type: text/x-rst
+Requires-Dist: opencv-python
+Requires-Dist: numpy
+Requires-Dist: click
+Provides-Extra: web
+Requires-Dist: aiohttp; extra == "web"
+
+cv-frames
+=========
+
+.. image:: https://github.com/kqf/cv-frames/actions/workflows/tests.yml/badge.svg
+   :target: https://github.com/kqf/cv-frames/actions
+   :alt: Tests
+
+.. image:: https://img.shields.io/pypi/dm/cv-frames.svg
+   :target: https://pypi.org/project/cv-frames/
+   :alt: PyPI Downloads
+
+``cv-frames`` is a lightweight utility that simplifies working with video files frame-by-frame using OpenCV.
+It includes both a Python API and a command-line interface (CLI) for interacting with video frames in an intuitive way.
+
+----
+
+Installation
+------------
+
+Install via pip:
+
+.. code-block:: bash
+
+    pip install cv-frames
+
+----
+
+Command Line Usage
+------------------
+
+After installation, you can use the CLI:
+
+.. code-block:: bash
+
+    cv-frames show path/to/video.mp4
+
+Navigate through frames with any key. Press **q** to quit.
+
+----
+
+Python Usage
+------------
+
+Example: Read and show frames programmatically
+
+.. code-block:: python
+
+    from pathlib import Path
+    from cvframes import iterate
+
+    for i, (_, frame) in enumerate(iterate(Path("video.mp4"))):
+        print(f"Frame {i} shape:", frame.shape)
+
+Example: Split side-by-side video into left/right frames
+
+.. code-block:: python
+
+    from cvframes import iterate_sbs
+
+    # Write the processed frames to disc
+    for capture, (left, right) in iterate_sbs("sbs_video.mp4", oname="processed.mp4"):
+        processed = do_something(left)
+        capture.write(processed)

cv_frames-0.0.2/README.rst

@@ -0,0 +1,63 @@
+cv-frames
+=========
+
+.. image:: https://github.com/kqf/cv-frames/actions/workflows/tests.yml/badge.svg
+   :target: https://github.com/kqf/cv-frames/actions
+   :alt: Tests
+
+.. image:: https://img.shields.io/pypi/dm/cv-frames.svg
+   :target: https://pypi.org/project/cv-frames/
+   :alt: PyPI Downloads
+
+``cv-frames`` is a lightweight utility that simplifies working with video files frame-by-frame using OpenCV.
+It includes both a Python API and a command-line interface (CLI) for interacting with video frames in an intuitive way.
+
+----
+
+Installation
+------------
+
+Install via pip:
+
+.. code-block:: bash
+
+    pip install cv-frames
+
+----
+
+Command Line Usage
+------------------
+
+After installation, you can use the CLI:
+
+.. code-block:: bash
+
+    cv-frames show path/to/video.mp4
+
+Navigate through frames with any key. Press **q** to quit.
+
+----
+
+Python Usage
+------------
+
+Example: Read and show frames programmatically
+
+.. code-block:: python
+
+    from pathlib import Path
+    from cvframes import iterate
+
+    for i, (_, frame) in enumerate(iterate(Path("video.mp4"))):
+        print(f"Frame {i} shape:", frame.shape)
+
+Example: Split side-by-side video into left/right frames
+
+.. code-block:: python
+
+    from cvframes import iterate_sbs
+
+    # Write the processed frames to disc
+    for capture, (left, right) in iterate_sbs("sbs_video.mp4", oname="processed.mp4"):
+        processed = do_something(left)
+        capture.write(processed)

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

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: cv-frames
+Version: 0.0.2
+Summary: Read frames from OpenCV like humans
+Description-Content-Type: text/x-rst
+Requires-Dist: opencv-python
+Requires-Dist: numpy
+Requires-Dist: click
+Provides-Extra: web
+Requires-Dist: aiohttp; extra == "web"
+
+cv-frames
+=========
+
+.. image:: https://github.com/kqf/cv-frames/actions/workflows/tests.yml/badge.svg
+   :target: https://github.com/kqf/cv-frames/actions
+   :alt: Tests
+
+.. image:: https://img.shields.io/pypi/dm/cv-frames.svg
+   :target: https://pypi.org/project/cv-frames/
+   :alt: PyPI Downloads
+
+``cv-frames`` is a lightweight utility that simplifies working with video files frame-by-frame using OpenCV.
+It includes both a Python API and a command-line interface (CLI) for interacting with video frames in an intuitive way.
+
+----
+
+Installation
+------------
+
+Install via pip:
+
+.. code-block:: bash
+
+    pip install cv-frames
+
+----
+
+Command Line Usage
+------------------
+
+After installation, you can use the CLI:
+
+.. code-block:: bash
+
+    cv-frames show path/to/video.mp4
+
+Navigate through frames with any key. Press **q** to quit.
+
+----
+
+Python Usage
+------------
+
+Example: Read and show frames programmatically
+
+.. code-block:: python
+
+    from pathlib import Path
+    from cvframes import iterate
+
+    for i, (_, frame) in enumerate(iterate(Path("video.mp4"))):
+        print(f"Frame {i} shape:", frame.shape)
+
+Example: Split side-by-side video into left/right frames
+
+.. code-block:: python
+
+    from cvframes import iterate_sbs
+
+    # Write the processed frames to disc
+    for capture, (left, right) in iterate_sbs("sbs_video.mp4", oname="processed.mp4"):
+        processed = do_something(left)
+        capture.write(processed)

{cv_frames-0.0.1 → cv_frames-0.0.2}/cv_frames.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 .gitignore
 .pre-commit-config.yaml
-README.md
+README.rst
 pyproject.toml
 requirements.txt
 .github/workflows/publish.yml
@@ -14,4 +14,8 @@ cv_frames.egg-info/top_level.txt
 cvframes/__init__.py
 cvframes/cli.py
 cvframes/iterate.py
+cvframes/web/__init__.py
+cvframes/web/client.py
+cvframes/web/server.py
+cvframes/web/static/index.html
 tests/test_iterate.py

{cv_frames-0.0.1 → cv_frames-0.0.2}/cv_frames.egg-info/requires.txt

@@ -1,3 +1,6 @@
 opencv-python
 numpy
 click
+
+[web]
+aiohttp

{cv_frames-0.0.1 → cv_frames-0.0.2}/cvframes/cli.py

@@ -1,3 +1,5 @@
+import asyncio
+
 import click
 import cv2
 
@@ -22,3 +24,14 @@ def show(filepath):
             break
 
     cv2.destroyAllWindows()
+
+
+@main.command(name="server")
+@click.option(
+    "--http-port", default=8000, help="Port for HTTP/WebSocket server."
+)
+@click.option("--tcp-port", default=9999, help="Port for TCP frame source.")
+def run(http_port, tcp_port):
+    from cvframes.web.server import main
+
+    asyncio.run(main(http_port, tcp_port))

cv_frames-0.0.2/cvframes/web/client.py

@@ -0,0 +1,50 @@
+import importlib
+
+try:
+    importlib.import_module("aiohttp")
+except ImportError as e:
+    print(
+        "❌ Missing required dependency: aiohttp\n"
+        "➡️  Please install it with:\n\n"
+        "   pip install cv-frames[web]\n"
+    )
+    raise SystemExit(1) from e
+
+import importlib
+import select
+import socket
+from contextlib import contextmanager
+
+import cv2
+
+
+class FrameStreamer:
+    def __init__(self, sock):
+        self.sock = sock
+
+    def imshow(self, frame):
+        _, buffer = cv2.imencode(".jpg", frame)
+        self.sock.sendall(buffer.tobytes())
+
+    def waitKey(self, timeout_ms=1000):
+        self.sock.setblocking(0)
+        ready = select.select([self.sock], [], [], timeout_ms / 1000.0)
+        if not ready[0]:
+            return -1
+
+        if data := self.sock.recv(1024):
+            msg = data.decode().strip()
+            return int(msg)
+        return -1
+
+
+@contextmanager
+def connect_to_server(host="127.0.0.1", port=9999):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.connect((host, port))
+    print("[Client] Connected to server")
+    try:
+        yield FrameStreamer(sock)
+    finally:
+        sock.close()
+        print("[Client] Disconnected")

cv_frames-0.0.2/cvframes/web/server.py

@@ -0,0 +1,184 @@
+import asyncio
+import contextlib
+import json
+
+try:
+    from aiohttp import web
+except ImportError as e:
+    missing = e.name if hasattr(e, "name") else "aiohttp"
+    print(
+        f"❌ Missing required dependency: {missing}\n"
+        f"➡️  Please install it with:\n\n"
+        f"   pip install cv-frames[web]\n"
+    )
+    raise SystemExit(1) from e
+
+import importlib.resources as pkg_resources
+
+MAPPING = {
+    "ArrowUp": 82,
+    "ArrowDown": 84,
+    "ArrowLeft": 81,
+    "ArrowRight": 83,
+    "Escape": 27,
+}
+
+
+async def broadcast_task(
+    frame_queue: asyncio.Queue,
+    clients: set,
+    clients_lock: asyncio.Lock,
+):
+    while True:
+        frame = await frame_queue.get()
+        async with clients_lock:
+            to_remove = set()
+            for ws in clients:
+                if ws.closed:
+                    to_remove.add(ws)
+                    continue
+                try:
+                    await ws.send_bytes(frame)
+                except Exception:
+                    to_remove.add(ws)
+            for ws in to_remove:
+                clients.remove(ws)
+        frame_queue.task_done()
+
+
+async def handle_tcp_connection(
+    reader,
+    writer,
+    frame_queue: asyncio.Queue,
+):
+    print("[TCP] Frame source connected")
+    buffer = b""
+
+    try:
+        while True:
+            chunk = await reader.read(4096)
+            if not chunk:
+                print("[TCP] Source disconnected")
+                break
+            buffer += chunk
+
+            while b"\xff\xd8" in buffer and b"\xff\xd9" in buffer:
+                start = buffer.find(b"\xff\xd8")
+                end = buffer.find(b"\xff\xd9") + 2
+                if end <= start:
+                    break
+                jpg = buffer[start:end]
+                buffer = buffer[end:]
+                await frame_queue.put(jpg)
+
+    except Exception as e:
+        print(f"[TCP] Error: {e}")
+    finally:
+        writer.close()
+        await writer.wait_closed()
+        print("[TCP] Connection closed")
+
+
+async def websocket_handler(request):
+    app = request.app
+    clients = app["clients"]
+    clients_lock = app["clients_lock"]
+    tcp_send_lock = app["tcp_send_lock"]
+    tcp_conn_writer = app.get("tcp_conn_writer")
+
+    ws = web.WebSocketResponse()
+    await ws.prepare(request)
+
+    print(f"[WS] Client connected: {request.remote}")
+    async with clients_lock:
+        clients.add(ws)
+
+    try:
+        async for msg in ws:
+            if msg.type == web.WSMsgType.TEXT:
+                try:
+                    data = json.loads(msg.data)
+                except json.JSONDecodeError:
+                    continue
+
+                if data.get("type") == "key":
+                    key = data.get("key")
+                    print(f"[WS] Key pressed: {key}")
+                    code = MAPPING.get(
+                        key, ord(key) if len(key) == 1 else None
+                    )
+                    if code is None:
+                        continue
+
+                    print(f"[WS] Sending key code: {code}")
+                    async with tcp_send_lock:
+                        if tcp_conn_writer := request.app.get(
+                            "tcp_conn_writer"
+                        ):
+                            tcp_conn_writer.write(f"{code}".encode())
+                            await tcp_conn_writer.drain()
+
+            elif msg.type == web.WSMsgType.ERROR:
+                print(f"[WS] Error: {ws.exception()}")
+                break
+
+    except Exception as e:
+        print(f"[WS] Receive error: {e}")
+
+    finally:
+        async with clients_lock:
+            clients.discard(ws)
+        print(f"[WS] Client disconnected: {request.remote}")
+
+    return ws
+
+
+async def main(http_port: int, tcp_port: int):
+    app = web.Application()
+
+    frame_queue: asyncio.Queue = asyncio.Queue()
+    clients: set[web.WebSocketResponse] = set()
+    clients_lock = asyncio.Lock()
+    tcp_send_lock = asyncio.Lock()
+    tcp_conn_writer = None
+
+    app["frame_queue"] = frame_queue
+    app["clients"] = clients
+    app["clients_lock"] = clients_lock
+    app["tcp_send_lock"] = tcp_send_lock
+    app["tcp_conn_writer"] = tcp_conn_writer
+
+    # Get static paths relative to package
+    index = pkg_resources.files("cvframes.web.static").joinpath("index.html")
+    static = pkg_resources.files("cvframes.web.static")
+
+    app.router.add_get("/", lambda request: web.FileResponse(index))
+    app.router.add_get("/ws", websocket_handler)
+    app.router.add_static("/static/", path=static, name="static")
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, "0.0.0.0", http_port)
+    await site.start()
+    print(f"✅ Server running at: http://localhost:{http_port}")
+
+    broadcaster = asyncio.create_task(
+        broadcast_task(frame_queue, clients, clients_lock)
+    )
+
+    async def tcp_server_callback(reader, writer):
+        app["tcp_conn_writer"] = writer
+        await handle_tcp_connection(reader, writer, frame_queue)
+        app["tcp_conn_writer"] = None
+
+    server = await asyncio.start_server(
+        tcp_server_callback, "0.0.0.0", tcp_port
+    )
+    print(f"[TCP] Waiting for frame source on port {tcp_port}")
+
+    async with server:
+        await server.serve_forever()
+
+    broadcaster.cancel()
+    with contextlib.suppress(asyncio.CancelledError):
+        await broadcaster

cv_frames-0.0.2/cvframes/web/static/index.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>Live Stream</title>
+    <style>
+        html, body {
+            margin: 0;
+            padding: 0;
+            height: 100%;
+            /* background: #255; */
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-family: sans-serif;
+        }
+
+        #stream-container {
+            position: relative;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            max-width: 100%;
+            max-height: 100%;
+        }
+
+        #stream {
+            max-width: 100%;
+            max-height: 100vh;
+            height: auto;
+            width: auto;
+            opacity: 1;
+            transition: opacity 0.2s;
+        }
+
+        #waiting-message {
+            position: absolute;
+            background: rgba(0, 0, 0, 0.6);
+            color: white;
+            padding: 10px 20px;
+            border-radius: 8px;
+            display: none;
+            font-size: 1.2rem;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="stream-container">
+        <img id="stream" />
+        <div id="waiting-message">Waiting for video...</div>
+    </div>
+
+    <script>
+        const ws = new WebSocket("ws://" + location.host + "/ws");
+        const img = document.getElementById("stream");
+        const waitingMessage = document.getElementById("waiting-message");
+
+        ws.binaryType = "arraybuffer";
+
+        function showPlaceholder() {
+            img.style.opacity = "0.3";
+            waitingMessage.style.display = "block";
+        }
+
+        function hidePlaceholder() {
+            img.style.opacity = "1";
+            waitingMessage.style.display = "none";
+        }
+
+        ws.onmessage = (event) => {
+            if (typeof event.data === "string") {
+                try {
+                    const msg = JSON.parse(event.data);
+                    if (msg.type === "waiting") {
+                        showPlaceholder();
+                        return;
+                    }
+                } catch (e) {
+                    console.warn("Invalid message:", event.data);
+                }
+            } else if (event.data instanceof ArrayBuffer) {
+                const blob = new Blob([event.data], { type: "image/jpeg" });
+                img.src = URL.createObjectURL(blob);
+                hidePlaceholder();
+            }
+        };
+
+        ws.onopen = () => {
+            console.log("Connected to WebSocket");
+
+            document.addEventListener("keydown", (e) => {
+                const msg = JSON.stringify({ type: "key", key: e.key });
+                ws.send(msg);
+            });
+        };
+    </script>
+</body>
+
+</html>

{cv_frames-0.0.1 → cv_frames-0.0.2}/pyproject.toml

@@ -29,17 +29,27 @@ build-backend = "setuptools.build_meta"
 name = "cv-frames"
 dynamic = ["version"]
 description = "Read frames from OpenCV like humans"
+readme = "README.rst"
+
 dependencies = [
     "opencv-python",
     "numpy",
     "click",
 ]
 
+[project.optional-dependencies]
+web = ["aiohttp"]
+
 [project.scripts]
 cv-frames = "cvframes.cli:main"
 
 [tool.setuptools]
-packages = ["cvframes"]
+packages = [
+    "cvframes",
+    "cvframes.web",
+    "cvframes.web.static",
+]
+include-package-data = true
 
 [tool.setuptools_scm]
 version_scheme = "post-release"  # Uses Git tags for versioning

cv_frames-0.0.1/PKG-INFO

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

cv_frames-0.0.1/README.md

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

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

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