py-termcam 0.2.0__tar.gz

py_termcam-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 termcam contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_termcam-0.2.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: py-termcam
+Version: 0.2.0
+Summary: Live webcam → terminal art in 8 styles, with a virtual camera for OBS. Works without a camera too.
+Author: termcam contributors
+License: MIT
+Keywords: webcam,terminal,ascii-art,creative-coding,cli,virtual-camera,obs
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video :: Capture
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.8
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Provides-Extra: webcam
+Requires-Dist: pyvirtualcam>=0.12; extra == "webcam"
+Requires-Dist: numpy>=1.24; extra == "webcam"
+Dynamic: license-file
+
+# termcam
+
+Your webcam — live — rendered in the terminal as ASCII, neon, dither or
+glitch art. One keystroke changes the style. No GUI windows, no browser, just
+the console and you.
+
+No webcam? **termcam** generates a procedural plasma that still reacts to
+your keystrokes and serves as a screensaver-style demo.
+
+## Install
+
+```bash
+pip install termcam                # terminal + window art
+pip install "termcam[webcam]"      # + virtual camera (--out webcam)
+```
+
+## Quick start
+
+```bash
+termcam                 # uses webcam, ascii style, 24 fps
+termcam --source synth  # no webcam needed — procedural plasma
+termcam --source url --url "http://192.168.1.5:8080/video"  # phone via IP Webcam
+termcam --out webcam --source synth   # art becomes a virtual camera device
+termcam --out window --source synth   # art in a GUI window (OBS Window Capture)
+```
+
+### Hotkeys (while running)
+
+| Key | Action                    |
+|-----|---------------------------|
+| a   | ASCII (luminance → chars) |
+| s   | Neon (color gradient)     |
+| d   | Dither (pixel noise)      |
+| g   | Glitch (sparkling)        |
+| e   | Sketch (edge detection)   |
+| h   | Halftone (newsprint)      |
+| t   | Thermal (heatmap)         |
+| x   | Negative (film invert)    |
+| m   | Mirror / un-mirror        |
+| q   | Quit                      |
+
+Press the style key repeatedly for palette variants.
+
+## Styles
+
+- **ASCII** — classic monochrome luminance ramp (`" .:-=+*#%@"`)
+- **Neon** — full color, mapped through an ANSI 256 palette
+- **Dither** — 4×4 Bayer matrix noise, retro pixel look
+- **Glitch** — per-frame hash sparkle, chaotic but alive
+- **Sketch** — edge detection (Sobel-like), pencil-look line art, light/dark paper
+- **Halftone** — newspaper print: ink shades on paper-color background
+- **Thermal** — heatmap palettes (fire, inferno, deep water, lava-pink)
+- **Negative** — film negative, posterized, cyan/magenta/warm X-ray tints
+
+Every style has palette/param variants — keep pressing its key to cycle.
+
+## CLI options
+
+```
+termcam
+  --source {camera,synth,url}  input source       (default: camera)
+  --style {ascii,neon,dith,glitch,sketch,halftone,thermal,negative} (default: ascii)
+  --out {terminal,webcam,window,both}             (default: terminal)
+  --fps N                      frames per second  (default: 24)
+  --cols N                     terminal width hint (auto-detected)
+  --device N                   camera device index (default: 0)
+  --url URL                    MJPEG stream for --source url
+  --backend {auto,obs,unitycapture} virtual camera backend (default: auto)
+  --webcam-size WxH            virtual camera resolution (default: 1280x720)
+  --mirror                     flip horizontally
+```
+
+## Virtual camera & OBS
+
+You can turn the art itself into a webcam device.
+
+**As a real webcam in ANY app including OBS** (best: no OBS dependency):
+
+```bash
+pip install "termcam[webcam]"
+termcam --source synth --out webcam --backend unitycapture
+```
+
+This uses the free, open-source [UnityCapture](https://github.com/schellingb/UnityCapture)
+DirectShow filter as the virtual camera device **`Unity Video Capture`**. Install it
+once as administrator:
+
+1. Clone/download [UnityCapture](https://github.com/schellingb/UnityCapture).
+2. From `UnityCapture/Install` run `Install.bat` as administrator (registers two
+   DLLs via `regsvr32`). Keep that folder in place while installed.
+3. In OBS: **Sources → + → Video Capture Device → Unity Video Capture**.
+   The device appears even while termcam runs without OBS active.
+
+Remove it later with `Uninstall.bat` (as administrator).
+
+**As a webcam in other apps** (Zoom, Discord, …), using OBS's own virtual camera:
+
+```bash
+termcam --out webcam --source synth
+```
+
+With the `obs` backend, start **OBS Studio → Start Virtual Camera** once, then pick
+`OBS Virtual Camera` as the camera in any other app. Cannot be consumed as an
+input inside the same OBS instance.
+
+**Preview window** (for OBS Window Capture if you prefer):
+
+```bash
+termcam --out window --source synth
+```
+
+A window titled `termcam` opens; in OBS add **Sources → Window Capture →
+termcam**.
+
+Hotkeys work in every output mode (`a/s/d/g/e/h/t/x`, `m`, `q`).
+
+## Phone as a webcam
+
+No USB webcam? Any Android phone with a WiFi connection works — termcam just
+needs a URL. Tested target: a 2016 Samsung Galaxy J1 Mini (Android 5.1).
+
+1. Install the free app **IP Webcam** on the phone (Play Store; works on
+   Android 5.0+).
+2. Connect the phone and your PC to the **same WiFi** network.
+3. Open IP Webcam → tap **Start server** at the bottom. The app shows an
+   address like `http://192.168.1.5:8080`.
+4. Verify on the PC in a browser: open that address — you should see the
+   camera preview. (Phone as a hotspot also works: connect the PC to the
+   phone's hotspot instead.)
+5. Point termcam at the MJPEG stream:
+
+   ```bash
+   termcam --source url --url "http://192.168.1.5:8080/video"
+   ```
+
+6. Hotkeys are the same — `a/s/d/g` switches styles, so the low-res J1 Mini
+   camera becomes lo-fi neon/dither art.
+
+If IP Webcam has a password set (Settings → Login), embed it in the URL:
+`http://user:pass@192.168.1.5:8080/video`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

py_termcam-0.2.0/README.md

@@ -0,0 +1,151 @@
+# termcam
+
+Your webcam — live — rendered in the terminal as ASCII, neon, dither or
+glitch art. One keystroke changes the style. No GUI windows, no browser, just
+the console and you.
+
+No webcam? **termcam** generates a procedural plasma that still reacts to
+your keystrokes and serves as a screensaver-style demo.
+
+## Install
+
+```bash
+pip install termcam                # terminal + window art
+pip install "termcam[webcam]"      # + virtual camera (--out webcam)
+```
+
+## Quick start
+
+```bash
+termcam                 # uses webcam, ascii style, 24 fps
+termcam --source synth  # no webcam needed — procedural plasma
+termcam --source url --url "http://192.168.1.5:8080/video"  # phone via IP Webcam
+termcam --out webcam --source synth   # art becomes a virtual camera device
+termcam --out window --source synth   # art in a GUI window (OBS Window Capture)
+```
+
+### Hotkeys (while running)
+
+| Key | Action                    |
+|-----|---------------------------|
+| a   | ASCII (luminance → chars) |
+| s   | Neon (color gradient)     |
+| d   | Dither (pixel noise)      |
+| g   | Glitch (sparkling)        |
+| e   | Sketch (edge detection)   |
+| h   | Halftone (newsprint)      |
+| t   | Thermal (heatmap)         |
+| x   | Negative (film invert)    |
+| m   | Mirror / un-mirror        |
+| q   | Quit                      |
+
+Press the style key repeatedly for palette variants.
+
+## Styles
+
+- **ASCII** — classic monochrome luminance ramp (`" .:-=+*#%@"`)
+- **Neon** — full color, mapped through an ANSI 256 palette
+- **Dither** — 4×4 Bayer matrix noise, retro pixel look
+- **Glitch** — per-frame hash sparkle, chaotic but alive
+- **Sketch** — edge detection (Sobel-like), pencil-look line art, light/dark paper
+- **Halftone** — newspaper print: ink shades on paper-color background
+- **Thermal** — heatmap palettes (fire, inferno, deep water, lava-pink)
+- **Negative** — film negative, posterized, cyan/magenta/warm X-ray tints
+
+Every style has palette/param variants — keep pressing its key to cycle.
+
+## CLI options
+
+```
+termcam
+  --source {camera,synth,url}  input source       (default: camera)
+  --style {ascii,neon,dith,glitch,sketch,halftone,thermal,negative} (default: ascii)
+  --out {terminal,webcam,window,both}             (default: terminal)
+  --fps N                      frames per second  (default: 24)
+  --cols N                     terminal width hint (auto-detected)
+  --device N                   camera device index (default: 0)
+  --url URL                    MJPEG stream for --source url
+  --backend {auto,obs,unitycapture} virtual camera backend (default: auto)
+  --webcam-size WxH            virtual camera resolution (default: 1280x720)
+  --mirror                     flip horizontally
+```
+
+## Virtual camera & OBS
+
+You can turn the art itself into a webcam device.
+
+**As a real webcam in ANY app including OBS** (best: no OBS dependency):
+
+```bash
+pip install "termcam[webcam]"
+termcam --source synth --out webcam --backend unitycapture
+```
+
+This uses the free, open-source [UnityCapture](https://github.com/schellingb/UnityCapture)
+DirectShow filter as the virtual camera device **`Unity Video Capture`**. Install it
+once as administrator:
+
+1. Clone/download [UnityCapture](https://github.com/schellingb/UnityCapture).
+2. From `UnityCapture/Install` run `Install.bat` as administrator (registers two
+   DLLs via `regsvr32`). Keep that folder in place while installed.
+3. In OBS: **Sources → + → Video Capture Device → Unity Video Capture**.
+   The device appears even while termcam runs without OBS active.
+
+Remove it later with `Uninstall.bat` (as administrator).
+
+**As a webcam in other apps** (Zoom, Discord, …), using OBS's own virtual camera:
+
+```bash
+termcam --out webcam --source synth
+```
+
+With the `obs` backend, start **OBS Studio → Start Virtual Camera** once, then pick
+`OBS Virtual Camera` as the camera in any other app. Cannot be consumed as an
+input inside the same OBS instance.
+
+**Preview window** (for OBS Window Capture if you prefer):
+
+```bash
+termcam --out window --source synth
+```
+
+A window titled `termcam` opens; in OBS add **Sources → Window Capture →
+termcam**.
+
+Hotkeys work in every output mode (`a/s/d/g/e/h/t/x`, `m`, `q`).
+
+## Phone as a webcam
+
+No USB webcam? Any Android phone with a WiFi connection works — termcam just
+needs a URL. Tested target: a 2016 Samsung Galaxy J1 Mini (Android 5.1).
+
+1. Install the free app **IP Webcam** on the phone (Play Store; works on
+   Android 5.0+).
+2. Connect the phone and your PC to the **same WiFi** network.
+3. Open IP Webcam → tap **Start server** at the bottom. The app shows an
+   address like `http://192.168.1.5:8080`.
+4. Verify on the PC in a browser: open that address — you should see the
+   camera preview. (Phone as a hotspot also works: connect the PC to the
+   phone's hotspot instead.)
+5. Point termcam at the MJPEG stream:
+
+   ```bash
+   termcam --source url --url "http://192.168.1.5:8080/video"
+   ```
+
+6. Hotkeys are the same — `a/s/d/g` switches styles, so the low-res J1 Mini
+   camera becomes lo-fi neon/dither art.
+
+If IP Webcam has a password set (Settings → Login), embed it in the URL:
+`http://user:pass@192.168.1.5:8080/video`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

py_termcam-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-termcam"
+version = "0.2.0"
+description = "Live webcam → terminal art in 8 styles, with a virtual camera for OBS. Works without a camera too."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "termcam contributors" }]
+keywords = ["webcam", "terminal", "ascii-art", "creative-coding", "cli", "virtual-camera", "obs"]
+classifiers = [
+    "Environment :: Console",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Video :: Capture",
+]
+dependencies = ["opencv-python>=4.8"]
+
+[project.scripts]
+termcam = "termcam.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+webcam = ["pyvirtualcam>=0.12", "numpy>=1.24"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

py_termcam-0.2.0/setup.cfg

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

py_termcam-0.2.0/src/py_termcam.egg-info/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: py-termcam
+Version: 0.2.0
+Summary: Live webcam → terminal art in 8 styles, with a virtual camera for OBS. Works without a camera too.
+Author: termcam contributors
+License: MIT
+Keywords: webcam,terminal,ascii-art,creative-coding,cli,virtual-camera,obs
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video :: Capture
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.8
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Provides-Extra: webcam
+Requires-Dist: pyvirtualcam>=0.12; extra == "webcam"
+Requires-Dist: numpy>=1.24; extra == "webcam"
+Dynamic: license-file
+
+# termcam
+
+Your webcam — live — rendered in the terminal as ASCII, neon, dither or
+glitch art. One keystroke changes the style. No GUI windows, no browser, just
+the console and you.
+
+No webcam? **termcam** generates a procedural plasma that still reacts to
+your keystrokes and serves as a screensaver-style demo.
+
+## Install
+
+```bash
+pip install termcam                # terminal + window art
+pip install "termcam[webcam]"      # + virtual camera (--out webcam)
+```
+
+## Quick start
+
+```bash
+termcam                 # uses webcam, ascii style, 24 fps
+termcam --source synth  # no webcam needed — procedural plasma
+termcam --source url --url "http://192.168.1.5:8080/video"  # phone via IP Webcam
+termcam --out webcam --source synth   # art becomes a virtual camera device
+termcam --out window --source synth   # art in a GUI window (OBS Window Capture)
+```
+
+### Hotkeys (while running)
+
+| Key | Action                    |
+|-----|---------------------------|
+| a   | ASCII (luminance → chars) |
+| s   | Neon (color gradient)     |
+| d   | Dither (pixel noise)      |
+| g   | Glitch (sparkling)        |
+| e   | Sketch (edge detection)   |
+| h   | Halftone (newsprint)      |
+| t   | Thermal (heatmap)         |
+| x   | Negative (film invert)    |
+| m   | Mirror / un-mirror        |
+| q   | Quit                      |
+
+Press the style key repeatedly for palette variants.
+
+## Styles
+
+- **ASCII** — classic monochrome luminance ramp (`" .:-=+*#%@"`)
+- **Neon** — full color, mapped through an ANSI 256 palette
+- **Dither** — 4×4 Bayer matrix noise, retro pixel look
+- **Glitch** — per-frame hash sparkle, chaotic but alive
+- **Sketch** — edge detection (Sobel-like), pencil-look line art, light/dark paper
+- **Halftone** — newspaper print: ink shades on paper-color background
+- **Thermal** — heatmap palettes (fire, inferno, deep water, lava-pink)
+- **Negative** — film negative, posterized, cyan/magenta/warm X-ray tints
+
+Every style has palette/param variants — keep pressing its key to cycle.
+
+## CLI options
+
+```
+termcam
+  --source {camera,synth,url}  input source       (default: camera)
+  --style {ascii,neon,dith,glitch,sketch,halftone,thermal,negative} (default: ascii)
+  --out {terminal,webcam,window,both}             (default: terminal)
+  --fps N                      frames per second  (default: 24)
+  --cols N                     terminal width hint (auto-detected)
+  --device N                   camera device index (default: 0)
+  --url URL                    MJPEG stream for --source url
+  --backend {auto,obs,unitycapture} virtual camera backend (default: auto)
+  --webcam-size WxH            virtual camera resolution (default: 1280x720)
+  --mirror                     flip horizontally
+```
+
+## Virtual camera & OBS
+
+You can turn the art itself into a webcam device.
+
+**As a real webcam in ANY app including OBS** (best: no OBS dependency):
+
+```bash
+pip install "termcam[webcam]"
+termcam --source synth --out webcam --backend unitycapture
+```
+
+This uses the free, open-source [UnityCapture](https://github.com/schellingb/UnityCapture)
+DirectShow filter as the virtual camera device **`Unity Video Capture`**. Install it
+once as administrator:
+
+1. Clone/download [UnityCapture](https://github.com/schellingb/UnityCapture).
+2. From `UnityCapture/Install` run `Install.bat` as administrator (registers two
+   DLLs via `regsvr32`). Keep that folder in place while installed.
+3. In OBS: **Sources → + → Video Capture Device → Unity Video Capture**.
+   The device appears even while termcam runs without OBS active.
+
+Remove it later with `Uninstall.bat` (as administrator).
+
+**As a webcam in other apps** (Zoom, Discord, …), using OBS's own virtual camera:
+
+```bash
+termcam --out webcam --source synth
+```
+
+With the `obs` backend, start **OBS Studio → Start Virtual Camera** once, then pick
+`OBS Virtual Camera` as the camera in any other app. Cannot be consumed as an
+input inside the same OBS instance.
+
+**Preview window** (for OBS Window Capture if you prefer):
+
+```bash
+termcam --out window --source synth
+```
+
+A window titled `termcam` opens; in OBS add **Sources → Window Capture →
+termcam**.
+
+Hotkeys work in every output mode (`a/s/d/g/e/h/t/x`, `m`, `q`).
+
+## Phone as a webcam
+
+No USB webcam? Any Android phone with a WiFi connection works — termcam just
+needs a URL. Tested target: a 2016 Samsung Galaxy J1 Mini (Android 5.1).
+
+1. Install the free app **IP Webcam** on the phone (Play Store; works on
+   Android 5.0+).
+2. Connect the phone and your PC to the **same WiFi** network.
+3. Open IP Webcam → tap **Start server** at the bottom. The app shows an
+   address like `http://192.168.1.5:8080`.
+4. Verify on the PC in a browser: open that address — you should see the
+   camera preview. (Phone as a hotspot also works: connect the PC to the
+   phone's hotspot instead.)
+5. Point termcam at the MJPEG stream:
+
+   ```bash
+   termcam --source url --url "http://192.168.1.5:8080/video"
+   ```
+
+6. Hotkeys are the same — `a/s/d/g` switches styles, so the low-res J1 Mini
+   camera becomes lo-fi neon/dither art.
+
+If IP Webcam has a password set (Settings → Login), embed it in the URL:
+`http://user:pass@192.168.1.5:8080/video`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

py_termcam-0.2.0/src/py_termcam.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+LICENSE
+README.md
+pyproject.toml
+src/py_termcam.egg-info/PKG-INFO
+src/py_termcam.egg-info/SOURCES.txt
+src/py_termcam.egg-info/dependency_links.txt
+src/py_termcam.egg-info/entry_points.txt
+src/py_termcam.egg-info/requires.txt
+src/py_termcam.egg-info/top_level.txt
+src/termcam/__init__.py
+src/termcam/__main__.py
+src/termcam/camera.py
+src/termcam/cli.py
+src/termcam/colors.py
+src/termcam/engine.py
+src/termcam/font.py
+src/termcam/frame.py
+src/termcam/keys.py
+src/termcam/renderer.py
+src/termcam/sources.py
+src/termcam/webcam.py
+src/termcam/styles/__init__.py
+src/termcam/styles/ascii.py
+src/termcam/styles/base.py
+src/termcam/styles/dither.py
+src/termcam/styles/glitch.py
+src/termcam/styles/halftone.py
+src/termcam/styles/negative.py
+src/termcam/styles/neon.py
+src/termcam/styles/sketch.py
+src/termcam/styles/thermal.py
+tests/test_cli.py
+tests/test_colors.py
+tests/test_frame.py
+tests/test_renderer.py
+tests/test_sources.py
+tests/test_styles.py
+tests/test_webcam.py

py_termcam-0.2.0/src/py_termcam.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_termcam-0.2.0/src/py_termcam.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+termcam = termcam.cli:main

py_termcam-0.2.0/src/py_termcam.egg-info/requires.txt

@@ -0,0 +1,8 @@
+opencv-python>=4.8
+
+[dev]
+pytest>=8.0
+
+[webcam]
+pyvirtualcam>=0.12
+numpy>=1.24

py_termcam-0.2.0/src/py_termcam.egg-info/top_level.txt

@@ -0,0 +1 @@
+termcam

py_termcam-0.2.0/src/termcam/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

py_termcam-0.2.0/src/termcam/camera.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import cv2
+
+from .frame import Frame
+
+
+def _read_and_resize(cap, cols: int, rows: int) -> Frame:
+    ok, frame = cap.read()
+    if not ok:
+        raise RuntimeError("Source returned no frame")
+    resized = cv2.resize(
+        frame,
+        (cols, rows * 2),
+        interpolation=cv2.INTER_AREA,
+    )
+    pixels = [
+        [(int(p[2]), int(p[1]), int(p[0])) for p in row] for row in resized
+    ]
+    return Frame(cols, rows * 2, pixels)
+
+
+class CameraSource:
+    def __init__(self, device: int = 0, cols: int = 80, rows: int = 40) -> None:
+        self.device = device
+        self.cols = cols
+        self.rows = rows
+        self._cap = cv2.VideoCapture(device)
+        if not self._cap.isOpened():
+            raise RuntimeError(f"Could not open camera device {device}")
+
+    def read(self) -> Frame:
+        try:
+            return _read_and_resize(self._cap, self.cols, self.rows)
+        except RuntimeError:
+            raise RuntimeError("Camera returned no frame") from None
+
+    def close(self) -> None:
+        self._cap.release()
+
+
+class UrlSource:
+    def __init__(self, url: str, cols: int = 80, rows: int = 40) -> None:
+        self.url = url
+        self.cols = cols
+        self.rows = rows
+        self._cap = cv2.VideoCapture(url)
+        if not self._cap.isOpened():
+            raise RuntimeError(f"Could not open stream at {url}")
+
+    def read(self) -> Frame:
+        try:
+            return _read_and_resize(self._cap, self.cols, self.rows)
+        except RuntimeError:
+            raise RuntimeError(f"Stream returned no frame: {self.url}") from None
+
+    def close(self) -> None:
+        self._cap.release()