weed-cli 2.6.2__tar.gz → 2.7.1__tar.gz

{weed_cli-2.6.2 → weed_cli-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 2.6.2
+Version: 2.7.1
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal
@@ -56,6 +56,7 @@ output (not simulated) — see [Status](#status) for what's verified.
   - [Interactive shell](#interactive-shell)
   - [Web UI](#web-ui)
   - [Orbit Visualizer](#orbit-visualizer)
+  - [Kodi add-on](#kodi-add-on)
   - [Orbit Visualizer plugins](#orbit-visualizer-plugins)
   - [Docker](#docker)
 - [Core mechanisms](#core-mechanisms)
@@ -225,7 +226,7 @@ The player's 🌀 button opens the **Orbit Visualizer**: a canvas driven by
 the track's audio (Web Audio analyser) and a low-res sample of its
 picture. Eleven built-in modes — Tunnel, Bars, Mirror, Scope, Spiral,
 Pixels, ASCII (six character sets, natural or neon), Plasma, Kaleido,
-Particles, Freefall — plus the seventeen in `web/orbit_extras.js` (next
+Particles, Freefall — plus the nineteen in `web/orbit_extras.js` (next
 section). Click the lit mode again for the plain video. Speed, React and
 Zoom retune every mode; every setting persists in the browser.
 
@@ -255,6 +256,11 @@ Zoom retune every mode; every setting persists in the browser.
   guest party page shows a 🔊 listen button; VLC takes both with
   `vlc --demux=mjpeg <view-url> --input-slave=<audio-url>`; OBS takes the
   audio URL as a second Media Source. Safari/iOS can't play WebM audio.
+  With ffmpeg on the node (the Docker image has it; otherwise
+  `$WEED_FFMPEG` or PATH), `/api/orbit-mux` is picture and audio as one
+  live Matroska stream, stream-copied, no transcoding -- for Kodi and
+  anything else that can't pair two URLs. Roku still can't: it wants
+  H.264, and this is MJPEG in a box.
 - **MIDI** (🎹): an AKAI MPK mini or any Web MIDI controller
   (Chrome/Edge/Firefox). Pads pick modes and fire actions, knobs turn
   the sliders or sweep through modes/transitions/character sets;
@@ -279,6 +285,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -286,6 +299,36 @@ Zoom retune every mode; every setting persists in the browser.
   slider in the picker, and the pairing is remembered per track. The
   picker has a search box for big libraries.
 
+### Kodi add-on
+
+`kodi/plugin.video.weed` is a Kodi add-on (Kodi 19 Matrix or later, any
+platform) that puts the node on a TV without streaming anything: it
+browses the node over the same web API the browser uses and plays the
+downloaded files through Kodi's own player, which handles every codec.
+Screens: **Downloads** (newest first, extensions dropped), **Playlists**
+with play-all, **Tags** as folders, **Party** (the vote list, select to
++1), **Autopilot** (the node's weighted least-played pick), and the
+**live Orbit feed** while the visualizer is streaming: picture and audio
+together (`/api/orbit-mux`, needs ffmpeg on the node), or the picture or
+the audio alone (the audio one lights up Kodi's own visualisers). Plays are counted on
+the node like the browser's.
+
+```bash
+make kodi                                  # -> dist/plugin.video.weed-<ver>.zip
+```
+
+On the Kodi box: Settings → Add-ons → *Unknown sources* on → *Install
+from zip file* → the zip (copy it over, or share it with the node's
+`/share`). Then open the add-on's settings and set the node URL, for
+example `http://192.168.1.137:8080`, and the token if the node runs with
+`--auth-token`. The add-on hands Kodi the `/api/stream/<job_id>` URLs
+with the token in the query, so seeking and resume work as for any file.
+An https node works too: the add-on accepts the node's self-signed
+certificate for its API calls (a setting, on by default), and sends the
+player to the plain stream port the node advertises
+(`--stream-plain-port`), falling back to https with Kodi's own
+`verifypeer=false` URL option when there is no plain port.
+
 ### Orbit Visualizer plugins
 
 The visualizer's modes and its Fade transitions are both open registries:
@@ -299,10 +342,12 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline and Globe, plus the
-Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom blur, RGB split, VHS,
-Win95, Blinds, Flip tiles, CRT off, Droplet, Blur, Slide and Flash
-transitions (Globe's coastlines are Natural Earth's public-domain 110m
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
+Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
+draw perspective faces as runs of affine strips, since Canvas 2D has no
+projection of its own; Globe's coastlines are Natural Earth's public-domain 110m
 land set, simplified into `web/land.json`); `web/orbit_plugin_example.js`
 is a minimal one to copy.
 
@@ -523,7 +568,10 @@ just designed:
 - Kademlia DHT discovery, survives the announcing node going offline
 - Local web UI with live progress, QR onboarding, HTTP range streaming,
   optional two-tier token auth, and the guest party page with voting
-- Orbit Visualizer: 28 modes and 23 transitions behind a plugin API,
+- Kodi add-on (`kodi/plugin.video.weed`): downloads, playlists, tags,
+  party votes, Autopilot pick and the live feeds on a TV through Kodi's
+  own player, 9 tests against a real node with Kodi stubbed.
+- Orbit Visualizer: 30 modes and 26 transitions behind a plugin API,
   MJPEG network stream (VLC/Roku), Web MIDI control with keymap files,
   video swap — 44 Playwright tests against real Chromium (`tests/e2e/`)
 - Containerized node (`Dockerfile.node`, `docker-compose.node.yml`),

{weed_cli-2.6.2 → weed_cli-2.7.1}/README.md

@@ -24,6 +24,7 @@ output (not simulated) — see [Status](#status) for what's verified.
   - [Interactive shell](#interactive-shell)
   - [Web UI](#web-ui)
   - [Orbit Visualizer](#orbit-visualizer)
+  - [Kodi add-on](#kodi-add-on)
   - [Orbit Visualizer plugins](#orbit-visualizer-plugins)
   - [Docker](#docker)
 - [Core mechanisms](#core-mechanisms)
@@ -193,7 +194,7 @@ The player's 🌀 button opens the **Orbit Visualizer**: a canvas driven by
 the track's audio (Web Audio analyser) and a low-res sample of its
 picture. Eleven built-in modes — Tunnel, Bars, Mirror, Scope, Spiral,
 Pixels, ASCII (six character sets, natural or neon), Plasma, Kaleido,
-Particles, Freefall — plus the seventeen in `web/orbit_extras.js` (next
+Particles, Freefall — plus the nineteen in `web/orbit_extras.js` (next
 section). Click the lit mode again for the plain video. Speed, React and
 Zoom retune every mode; every setting persists in the browser.
 
@@ -223,6 +224,11 @@ Zoom retune every mode; every setting persists in the browser.
   guest party page shows a 🔊 listen button; VLC takes both with
   `vlc --demux=mjpeg <view-url> --input-slave=<audio-url>`; OBS takes the
   audio URL as a second Media Source. Safari/iOS can't play WebM audio.
+  With ffmpeg on the node (the Docker image has it; otherwise
+  `$WEED_FFMPEG` or PATH), `/api/orbit-mux` is picture and audio as one
+  live Matroska stream, stream-copied, no transcoding -- for Kodi and
+  anything else that can't pair two URLs. Roku still can't: it wants
+  H.264, and this is MJPEG in a box.
 - **MIDI** (🎹): an AKAI MPK mini or any Web MIDI controller
   (Chrome/Edge/Firefox). Pads pick modes and fire actions, knobs turn
   the sliders or sweep through modes/transitions/character sets;
@@ -247,6 +253,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -254,6 +267,36 @@ Zoom retune every mode; every setting persists in the browser.
   slider in the picker, and the pairing is remembered per track. The
   picker has a search box for big libraries.
 
+### Kodi add-on
+
+`kodi/plugin.video.weed` is a Kodi add-on (Kodi 19 Matrix or later, any
+platform) that puts the node on a TV without streaming anything: it
+browses the node over the same web API the browser uses and plays the
+downloaded files through Kodi's own player, which handles every codec.
+Screens: **Downloads** (newest first, extensions dropped), **Playlists**
+with play-all, **Tags** as folders, **Party** (the vote list, select to
++1), **Autopilot** (the node's weighted least-played pick), and the
+**live Orbit feed** while the visualizer is streaming: picture and audio
+together (`/api/orbit-mux`, needs ffmpeg on the node), or the picture or
+the audio alone (the audio one lights up Kodi's own visualisers). Plays are counted on
+the node like the browser's.
+
+```bash
+make kodi                                  # -> dist/plugin.video.weed-<ver>.zip
+```
+
+On the Kodi box: Settings → Add-ons → *Unknown sources* on → *Install
+from zip file* → the zip (copy it over, or share it with the node's
+`/share`). Then open the add-on's settings and set the node URL, for
+example `http://192.168.1.137:8080`, and the token if the node runs with
+`--auth-token`. The add-on hands Kodi the `/api/stream/<job_id>` URLs
+with the token in the query, so seeking and resume work as for any file.
+An https node works too: the add-on accepts the node's self-signed
+certificate for its API calls (a setting, on by default), and sends the
+player to the plain stream port the node advertises
+(`--stream-plain-port`), falling back to https with Kodi's own
+`verifypeer=false` URL option when there is no plain port.
+
 ### Orbit Visualizer plugins
 
 The visualizer's modes and its Fade transitions are both open registries:
@@ -267,10 +310,12 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline and Globe, plus the
-Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom blur, RGB split, VHS,
-Win95, Blinds, Flip tiles, CRT off, Droplet, Blur, Slide and Flash
-transitions (Globe's coastlines are Natural Earth's public-domain 110m
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
+Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
+draw perspective faces as runs of affine strips, since Canvas 2D has no
+projection of its own; Globe's coastlines are Natural Earth's public-domain 110m
 land set, simplified into `web/land.json`); `web/orbit_plugin_example.js`
 is a minimal one to copy.
 
@@ -491,7 +536,10 @@ just designed:
 - Kademlia DHT discovery, survives the announcing node going offline
 - Local web UI with live progress, QR onboarding, HTTP range streaming,
   optional two-tier token auth, and the guest party page with voting
-- Orbit Visualizer: 28 modes and 23 transitions behind a plugin API,
+- Kodi add-on (`kodi/plugin.video.weed`): downloads, playlists, tags,
+  party votes, Autopilot pick and the live feeds on a TV through Kodi's
+  own player, 9 tests against a real node with Kodi stubbed.
+- Orbit Visualizer: 30 modes and 26 transitions behind a plugin API,
   MJPEG network stream (VLC/Roku), Web MIDI control with keymap files,
   video swap — 44 Playwright tests against real Chromium (`tests/e2e/`)
 - Containerized node (`Dockerfile.node`, `docker-compose.node.yml`),

{weed_cli-2.6.2 → weed_cli-2.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "2.6.2"
+version = "2.7.1"
 description = "Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel"
 readme = "README.md"
 license = { text = "MIT" }

weed_cli-2.7.1/tests/test_kodi_addon.py

@@ -0,0 +1,267 @@
+"""The Kodi add-on (kodi/plugin.video.weed) against a real, isolated
+web_ui server -- same fixture as the API tests. Kodi itself isn't here:
+the add-on keeps every decision in resources/lib/plugin.py behind a
+small ui object, and FakeUI below records what a real Kodi would have
+been told to draw or play. default.py (the xbmc glue) is only checked
+for syntax and the URL it builds, with the xbmc modules stubbed."""
+import importlib.util
+import os
+import sys
+import types
+
+import pytest
+
+import web_ui
+from testutil import http_get_json, http_post_json
+
+ADDON = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'kodi', 'plugin.video.weed')
+sys.path.insert(0, ADDON)
+from resources.lib import plugin, weedapi   # noqa: E402
+
+
+class FakeUI:
+    def __init__(self, server, token=None):
+        self._settings = {'server': server, 'token': token or ''}
+        self.folders, self.items, self.played, self.queued, self.notices, self.ended = [], [], [], [], [], []
+
+    def settings(self): return dict(self._settings)
+    def folder(self, label, action, **params): self.folders.append((label, action, params))
+    def media(self, label, url, info, action, **params): self.items.append((label, url, info, action, params))
+    def end(self, content=None): self.ended.append(content)
+    def play(self, url, label, info): self.played.append((url, label, info))
+    def play_all(self, entries): self.queued.append(entries)
+    def notify(self, message): self.notices.append(message)
+
+
+def _seed(n=3):
+    with web_ui._lock:
+        for i in range(n):
+            h = chr(ord('a') + i) * 64
+            web_ui._library['downloads'][h] = {
+                'content_hash': h, 'job_id': 'job%d' % i, 'path': '/x/%d.%s' % (i, 'mp3' if i == 2 else 'mp4'),
+                'title': 'Track %d.%s' % (i, 'mp3' if i == 2 else 'mp4'), 'downloaded_at': 100 + i, 'size': 1000 * (i + 1),
+                'play_count': i, 'tags': ['chill'] if i < 2 else ['party'],
+            }
+        web_ui._library['downloads']['unfinished'] = {'content_hash': 'unfinished', 'title': 'Not yet'}
+        web_ui._library['playlists'] = [{'id': 'pl1', 'name': 'Late', 'items': [
+            {'content_hash': 'b' * 64, 'title': 'Track 1.mp4'}, {'content_hash': 'a' * 64, 'title': 'Track 0.mp4'}, {'content_hash': 'zz', 'title': 'gone'}]}]
+        web_ui._save_library()
+
+
+def test_display_title_drops_only_a_media_extension():
+    assert weedapi.display_title('Late Night Mix.mp3') == 'Late Night Mix'
+    assert weedapi.display_title('Track 8.MP4') == 'Track 8'
+    assert weedapi.display_title('v1.2 notes') == 'v1.2 notes'
+    assert weedapi.display_title(None) == ''
+
+
+def test_root_and_downloads_list_finished_tracks_newest_first(web_server):
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run()
+    assert [f[1] for f in ui.folders] == ['downloads', 'playlists', 'tags', 'party', 'live', 'live', 'live', 'autopilot']
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='downloads')
+    assert [m[0] for m in ui.items] == ['Track 2', 'Track 1', 'Track 0']          # newest first, extension dropped, no unfinished
+    label, url, info, action, params = ui.items[0]
+    assert url == web_server + '/api/stream/job2' and action == 'play'
+    assert params['job_id'] == 'job2' and params['content_hash'] == 'c' * 64
+    assert info['mediatype'] == 'song' and info['playcount'] == 2               # an mp3 is a song, and the count comes through
+    assert ui.ended == ['musicvideos']
+
+
+def test_tags_playlists_and_play_all(web_server):
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='tags')
+    assert [f[0] for f in ui.folders] == ['chill (2)', 'party (1)']
+    assert ui.folders[0][2] == {'tag': 'chill'}
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='downloads', tag='chill', sort='title')
+    assert [m[0] for m in ui.items] == ['Track 0', 'Track 1']
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='playlists')
+    assert ui.folders == [('Late (3)', 'playlist', {'id': 'pl1'})]
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='playlist', id='pl1')
+    assert ui.folders[0][1] == 'playall'
+    assert [m[0] for m in ui.items] == ['Track 1', 'Track 0']                  # playlist order, the undownloaded one skipped
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='playall', id='pl1')
+    assert [e[0] for e in ui.queued[0]] == [web_server + '/api/stream/job1', web_server + '/api/stream/job0']
+
+
+def test_play_resolves_the_stream_url_and_counts_the_play(web_server):
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='play', job_id='job0', content_hash='a' * 64, title='Track 0')
+    assert ui.played == [(web_server + '/api/stream/job0', 'Track 0', {'title': 'Track 0'})]
+    lib = http_get_json(web_server + '/api/library')
+    rec = next(d for d in lib['downloads'] if d['content_hash'] == 'a' * 64)
+    assert rec['play_count'] == 1 and rec['last_played'] > 0
+    assert lib['history'][0]['content_hash'] == 'a' * 64
+
+
+def test_autopilot_pick_never_chooses_nothing_and_counts(web_server):
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='autopilot')
+    assert len(ui.played) == 1 and ui.played[0][0].startswith(web_server + '/api/stream/job')
+    lib = http_get_json(web_server + '/api/library')
+    assert sum(d.get('play_count', 0) for d in lib['downloads']) == 0 + 1 + 2 + 1   # one more play somewhere
+
+
+def test_token_goes_in_the_header_and_the_stream_query(web_server, monkeypatch):
+    _seed()
+    monkeypatch.setattr(web_ui, 'AUTH_TOKEN', 'admin-tok')
+    ui = FakeUI(web_server, token='admin-tok')
+    plugin.Plugin(ui).run(action='downloads')
+    assert ui.items and ui.items[0][1].endswith('/api/stream/job2?token=admin-tok')
+    # a wrong token is a clear message, not a stack trace
+    ui = FakeUI(web_server, token='nope')
+    plugin.Plugin(ui).run(action='downloads')
+    assert ui.items == [] and 'token' in ui.notices[0]
+
+
+def test_live_feeds_and_party_when_nothing_is_streaming(web_server):
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='live', what='view')
+    assert ui.played == [] and 'not streaming' in ui.notices[0]
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='party')
+    assert ui.folders and all(f[1] == 'vote' or f[1] == 'party' for f in ui.folders)
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='vote', content_hash='a' * 64)
+    assert ui.notices == ['voted']
+    party = http_get_json(web_server + '/api/party')
+    assert any(t['content_hash'] == 'a' * 64 and (t.get('votes') or t.get('score')) for t in party['tracks'])
+
+
+def test_no_server_set_is_a_settings_hint_not_a_crash():
+    ui = FakeUI('')
+    plugin.Plugin(ui).run(action='downloads')
+    assert 'settings' in ui.notices[0] and ui.ended == [None]
+
+
+def test_default_py_builds_plugin_urls_with_stubbed_kodi(monkeypatch):
+    """default.py imports the xbmc modules at the top; stub them and check
+    the glue: settings come from the add-on, a folder becomes a
+    plugin:// URL with the action and params in the query."""
+    calls = []
+    xbmc = types.SimpleNamespace(log=lambda *a: None, LOGINFO=1, PLAYLIST_VIDEO=1,
+                                 Player=lambda: types.SimpleNamespace(play=lambda *a: calls.append(('play',) + a)),
+                                 PlayList=lambda k: types.SimpleNamespace(clear=lambda: None, add=lambda *a: calls.append(('add',) + a)))
+    xbmcaddon = types.SimpleNamespace(Addon=lambda: types.SimpleNamespace(
+        getAddonInfo=lambda k: ADDON, getSetting=lambda k: {'server': 'http://node:8080', 'token': 't', 'insecure': 'true'}[k]))
+    xbmcgui = types.SimpleNamespace(ListItem=lambda **kw: types.SimpleNamespace(setInfo=lambda *a: None, setProperty=lambda *a: None, **kw),
+                                    Dialog=lambda: types.SimpleNamespace(notification=lambda *a: calls.append(('notify',) + a)), NOTIFICATION_INFO=0)
+    xbmcplugin = types.SimpleNamespace(addDirectoryItem=lambda h, url, item, isFolder=False: calls.append(('dir', url, item.label, isFolder)),
+                                       endOfDirectory=lambda h: calls.append(('end',)), setContent=lambda h, c: calls.append(('content', c)),
+                                       setResolvedUrl=lambda h, ok, item: calls.append(('resolved', item.path)))
+    for name, mod in (('xbmc', xbmc), ('xbmcaddon', xbmcaddon), ('xbmcgui', xbmcgui), ('xbmcplugin', xbmcplugin)):
+        monkeypatch.setitem(sys.modules, name, mod)
+    monkeypatch.setattr(sys, 'argv', ['plugin://plugin.video.weed/', '7', '?action=root'])
+    spec = importlib.util.spec_from_file_location('weed_default', os.path.join(ADDON, 'default.py'))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    ui = mod.KodiUI()
+    assert ui.settings() == {'server': 'http://node:8080', 'token': 't', 'insecure': True}
+    ui.folder('Downloads', 'downloads', tag='chill')
+    assert calls[-1] == ('dir', 'plugin://plugin.video.weed/?action=downloads&tag=chill', 'Downloads', True)
+    ui.media('Track', 'http://node:8080/api/stream/j1?token=t', {'title': 'Track', 'mediatype': 'musicvideo'}, action='play', job_id='j1', content_hash='h', title='Track')
+    assert calls[-1][1] == 'plugin://plugin.video.weed/?action=play&job_id=j1&content_hash=h&title=Track' and calls[-1][3] is False
+    ui.end('musicvideos')
+    assert calls[-2:] == [('content', 'musicvideos'), ('end',)]
+    ui.play('http://node:8080/api/stream/j1?token=t', 'Track', {'title': 'Track'})
+    assert calls[-1][0] == 'play'                                             # not invoked as a resolver here
+    monkeypatch.setattr(sys, 'argv', ['plugin://plugin.video.weed/', '7', '?action=play&job_id=j1'])
+    ui.play('http://node:8080/api/stream/j1?token=t', 'Track', {'title': 'Track'})
+    assert calls[-1] == ('resolved', 'http://node:8080/api/stream/j1?token=t')
+
+
+def test_kodi_own_url_parameters_are_ignored(web_server):
+    """Ryan's first launch: Kodi opens a video+audio add-on with
+    ?content_type=video, which crashed do_root(). Any parameter a screen
+    doesn't declare is dropped, on every screen."""
+    _seed()
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(content_type='video')
+    assert [f[1] for f in ui.folders][:2] == ['downloads', 'playlists'] and not ui.notices
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='downloads', content_type='audio', tag='chill')
+    assert [m[0] for m in ui.items] == ['Track 1', 'Track 0'] and not ui.notices
+
+
+def test_live_feed_urls_come_from_the_configured_node_not_its_advertised_plain_port(web_server, monkeypatch):
+    """Ryan: "unable to view the orbit stream, the log says it's trying
+    4242, but that's the old port". The node still advertised a plain
+    stream port that was no longer exposed; the add-on now builds the feed
+    URLs from its own node URL, with the token, and only takes the
+    advertised plain URL when the node is https."""
+    _seed()
+    monkeypatch.setattr(web_ui, '_orbit_ws_connected', True)
+    monkeypatch.setattr(web_ui, 'STREAM_PLAIN_PORT', 4242)
+    monkeypatch.setattr(web_ui, 'AUTH_TOKEN', 'admin-tok')
+    ui = FakeUI(web_server, token='admin-tok')
+    plugin.Plugin(ui).run(action='live', what='view')
+    assert ui.played and ui.played[0][0] == web_server + '/api/orbit-view?token=admin-tok'
+    assert ':4242' not in ui.played[0][0]
+    monkeypatch.setitem(web_ui._orbit_audio, 'on', True)
+    ui = FakeUI(web_server, token='admin-tok')
+    plugin.Plugin(ui).run(action='live', what='audio')
+    assert ui.played and ui.played[0][0] == web_server + '/api/orbit-audio?token=admin-tok'
+
+
+def test_https_node_sends_media_through_its_plain_port_or_skips_verification():
+    """Ryan: "seems that I need the tls for it to work, but the firestick
+    doesn't have the cert installed". The API calls tolerate the self-
+    signed certificate; the player never sees https when the node
+    advertises a plain stream port, and gets Kodi's verifypeer=false
+    option when it doesn't."""
+    import io, json as _json
+    class Resp:
+        def __init__(self, body): self._b = _json.dumps(body).encode()
+        def read(self): return self._b
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+    seen = []
+    def opener_with_plain(req, timeout=None):
+        seen.append(req.full_url)
+        return Resp({'active': False, 'plain_url': 'http://192.168.1.137:8081/api/orbit-view?token=t', 'audio_plain_url': 'http://192.168.1.137:8081/api/orbit-audio?token=t'})
+    api = weedapi.WeedApi('https://192.168.1.137:8080', 't', opener=opener_with_plain)
+    assert api.is_tls
+    assert api.stream_url('job1') == 'http://192.168.1.137:8081/api/stream/job1?token=t'
+    assert api.feed_url('view') == 'http://192.168.1.137:8081/api/orbit-view?token=t'
+    assert api.feed_url('audio') == 'http://192.168.1.137:8081/api/orbit-audio?token=t'
+    assert seen == ['https://192.168.1.137:8080/api/orbit-stream']              # asked once, then cached
+    def opener_no_plain(req, timeout=None):
+        return Resp({'active': False, 'plain_url': None, 'audio_plain_url': None})
+    api = weedapi.WeedApi('https://node:8080', 't', opener=opener_no_plain)
+    assert api.stream_url('job1') == 'https://node:8080/api/stream/job1?token=t|verifypeer=false'
+    assert api.feed_url('audio') == 'https://node:8080/api/orbit-audio?token=t|verifypeer=false'
+    # a plain http node never touches the advertised plain port at all
+    def opener_stale(req, timeout=None):
+        return Resp({'active': True, 'plain_url': 'http://node:4242/api/orbit-view'})
+    api = weedapi.WeedApi('http://node:8080', None, opener=opener_stale)
+    assert api.stream_url('job1') == 'http://node:8080/api/stream/job1'
+    assert api.feed_url('view') == 'http://node:8080/api/orbit-view'
+
+
+def test_muxed_live_feed_needs_audio_and_ffmpeg(web_server, monkeypatch):
+    """The picture+audio entry: one Matroska URL when the node has ffmpeg
+    and audio is on; a plain notice otherwise."""
+    _seed()
+    monkeypatch.setattr(web_ui, '_orbit_ws_connected', True)
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='live', what='mux')
+    assert ui.played == [] and 'no audio' in ui.notices[0]
+    monkeypatch.setitem(web_ui._orbit_audio, 'on', True)
+    monkeypatch.setattr(web_ui, '_ffmpeg_path', lambda: None)
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='live', what='mux')
+    assert ui.played == [] and 'ffmpeg' in ui.notices[0]
+    monkeypatch.setattr(web_ui, '_ffmpeg_path', lambda: '/usr/bin/ffmpeg')
+    ui = FakeUI(web_server)
+    plugin.Plugin(ui).run(action='live', what='mux')
+    assert ui.played == [(web_server + '/api/orbit-mux', 'weed Orbit', {'title': 'weed Orbit', 'mediatype': 'video'})]

{weed_cli-2.6.2 → weed_cli-2.7.1}/tests/test_orbit_audio.py

@@ -469,3 +469,25 @@ def test_audio_endpoint_takes_the_token_in_the_query(web_server, monkeypatch):
     s, head = audio_connect(web_server, '/api/orbit-audio?token=guest-tok')
     assert head.startswith(b'HTTP/1.1 404')   # past auth; just no audio yet
     s.close()
+
+
+def test_mux_endpoint_says_plainly_why_it_cannot(web_server, monkeypatch):
+    from testutil import http_get_json
+    import urllib.error, urllib.request, json as _json
+    def get(path):
+        try:
+            with urllib.request.urlopen(web_server + path) as r:
+                return r.status, _json.loads(r.read())
+        except urllib.error.HTTPError as e:
+            return e.code, _json.loads(e.read())
+    monkeypatch.setattr(web_ui, '_ffmpeg_path', lambda: None)
+    status, body = get('/api/orbit-mux')
+    assert status == 503 and 'ffmpeg' in body['error']
+    monkeypatch.setattr(web_ui, '_ffmpeg_path', lambda: '/usr/bin/ffmpeg')
+    status, body = get('/api/orbit-mux')
+    assert status == 404 and 'not streaming' in body['error']
+    monkeypatch.setattr(web_ui, '_orbit_ws_connected', True)
+    status, body = get('/api/orbit-mux')
+    assert status == 404 and 'audio' in body['error']
+    st = http_get_json(web_server + '/api/orbit-stream')
+    assert st['ffmpeg'] is True and st['mux'] is False and st['mux_url'].endswith('/api/orbit-mux')

{weed_cli-2.6.2 → weed_cli-2.7.1}/web_ui.py

@@ -25,6 +25,7 @@ import signal
 import socket
 import queue
 import secrets
+import shutil
 import ssl
 import struct
 import subprocess
@@ -575,6 +576,14 @@ class _LiveContainerRelay:
 _orbit_audio_relay = _LiveContainerRelay()
 
 
+def _ffmpeg_path():
+    """ffmpeg for the muxed feed (/api/orbit-mux): $WEED_FFMPEG, else on PATH, else None."""
+    p = os.environ.get('WEED_FFMPEG')
+    if p and os.access(p, os.X_OK):
+        return p
+    return shutil.which('ffmpeg')
+
+
 def _ws_unmask(data, mask_key):
     """Client->server WebSocket payloads arrive XOR-masked with a 4-byte
     key. Done as one big-int XOR rather than a per-byte Python loop:
@@ -1219,14 +1228,14 @@ class Handler(BaseHTTPRequestHandler):
 
     # GET endpoints a guest (stream token) may use; everything else under
     # /api/ is admin-only. The stream endpoints also take ?token=.
-    _GUEST_GET = ('/api/orbit-view', '/api/orbit-audio', '/api/orbit-stream', '/api/config', '/api/party', '/api/chat')
+    _GUEST_GET = ('/api/orbit-view', '/api/orbit-audio', '/api/orbit-mux', '/api/orbit-stream', '/api/config', '/api/party', '/api/chat')
 
     def do_GET(self):
         parsed = urlparse(self.path)
         path, qs = parsed.path, parse_qs(parsed.query)
 
         if path.startswith('/api/'):
-            takes_query_token = path in ('/api/orbit-view', '/api/orbit-audio') or path.startswith('/api/stream/')
+            takes_query_token = path in ('/api/orbit-view', '/api/orbit-audio', '/api/orbit-mux') or path.startswith('/api/stream/')
             q = qs if takes_query_token else None
             guest_ok = takes_query_token or path in self._GUEST_GET
             if not (self._guest_ok(q) if guest_ok else self._authorized(q)):
@@ -1322,6 +1331,8 @@ class Handler(BaseHTTPRequestHandler):
             return self._handle_orbit_view()
         if path == '/api/orbit-audio-ws':
             return self._handle_orbit_audio_websocket(qs)
+        if path == '/api/orbit-mux':
+            return self._handle_orbit_mux()
         if path == '/api/orbit-audio':
             return self._handle_orbit_audio()
         if path == '/api/orbit-stream':
@@ -2036,6 +2047,11 @@ class Handler(BaseHTTPRequestHandler):
             'audio_listeners': _orbit_audio_relay.subscriber_count(),
             'audio_url': f'{scheme}://{host}/api/orbit-audio{token_qs}',
             'audio_plain_url': f'{plain_base}/api/orbit-audio{token_qs}' if plain_base else None,
+            # picture + audio as one Matroska stream (ffmpeg on the node, stream copy)
+            'ffmpeg': bool(_ffmpeg_path()),
+            'mux': bool(active and audio.get('on') and _ffmpeg_path()),
+            'mux_url': f'{scheme}://{host}/api/orbit-mux{token_qs}',
+            'mux_plain_url': f'{plain_base}/api/orbit-mux{token_qs}' if plain_base else None,
         })
 
     def _handle_orbit_view(self):
@@ -2276,6 +2292,103 @@ class Handler(BaseHTTPRequestHandler):
         finally:
             _orbit_audio_relay.unsubscribe(q)
 
+    def _handle_orbit_mux(self):
+        """Picture and audio as ONE live stream -- Matroska with the MJPEG
+        frames and the Opus audio copied in as they are, no transcoding --
+        for players that can't pair two URLs (Kodi, most TV apps). ffmpeg
+        on the node does the muxing: each viewer gets its own process fed
+        through two FIFOs, the JPEG frames from the picture fanout and the
+        container bytes from the audio relay, and its stdout is this
+        response. Timestamps: the picture is stamped by arrival time, the
+        audio keeps its recorder's own clock, and ffmpeg starts both at
+        zero, so they line up to within the recorder's blob interval.
+        503 with a plain message when there's no ffmpeg on the node, 404
+        while nothing (or no audio) is streaming."""
+        ffmpeg = _ffmpeg_path()
+        if not ffmpeg:
+            return self._json({'error': 'the node has no ffmpeg -- the picture+audio feed needs it '
+                                        '(apt-get install ffmpeg on the node, or set WEED_FFMPEG to the binary)'}, status=503)
+        with _orbit_ws_lock:
+            active = _orbit_ws_connected
+        with _orbit_audio_lock:
+            on, mime = _orbit_audio['on'], _orbit_audio['mime']
+        if not active:
+            return self._json({'error': 'the visualizer is not streaming right now'}, status=404)
+        if not on or not mime:
+            return self._json({'error': 'the stream has no audio right now (the streamer\'s 🔊 toggle is off)'}, status=404)
+        afmt = 'ogg' if 'ogg' in mime else 'webm'
+        tmp = tempfile.mkdtemp(prefix='weed-mux-')
+        vfifo, afifo = os.path.join(tmp, 'v.mjpeg'), os.path.join(tmp, 'a.' + afmt)
+        os.mkfifo(vfifo); os.mkfifo(afifo)
+        vq = queue.Queue(maxsize=4)
+        with _orbit_subs_lock:
+            _orbit_subscribers.add(vq)
+        aq = _orbit_audio_relay.subscribe()
+        stop = threading.Event()
+
+        def pump(q, path):
+            # opening a FIFO for writing blocks until ffmpeg opens it to
+            # read, which it does input by input, so each pump waits its turn
+            try:
+                with open(path, 'wb', buffering=0) as f:
+                    while not stop.is_set():
+                        try:
+                            item = q.get(timeout=1)
+                        except queue.Empty:
+                            continue
+                        if item is None:
+                            break
+                        f.write(item)
+            except OSError:
+                pass
+            finally:
+                stop.set()
+
+        cmd = [ffmpeg, '-nostdin', '-hide_banner', '-loglevel', 'error',
+               '-use_wallclock_as_timestamps', '1', '-f', 'mjpeg', '-i', vfifo,
+               '-f', afmt, '-i', afifo,
+               '-map', '0:v:0', '-map', '1:a:0', '-c', 'copy',
+               '-f', 'matroska', '-live', '1', '-cluster_time_limit', '500', '-cluster_size_limit', '65536',
+               '-flush_packets', '1', 'pipe:1']
+        proc = None
+        try:
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+            for q, path in ((vq, vfifo), (aq, afifo)):
+                threading.Thread(target=pump, args=(q, path), daemon=True).start()
+            try:
+                self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            except OSError:
+                pass
+            self.send_response(200)
+            self.send_header('Content-Type', 'video/x-matroska')
+            self.send_header('Cache-Control', 'no-cache')
+            self.send_header('Connection', 'close')
+            self.end_headers()
+            self.wfile.flush()
+            while True:
+                data = proc.stdout.read1(65536)
+                if not data:
+                    break
+                try:
+                    self.wfile.write(data)
+                    self.wfile.flush()
+                except OSError:
+                    break
+        except Exception:
+            pass
+        finally:
+            stop.set()
+            if proc is not None:
+                try:
+                    proc.kill(); proc.wait(timeout=5)
+                except Exception:
+                    pass
+            with _orbit_subs_lock:
+                _orbit_subscribers.discard(vq)
+            _orbit_audio_relay.unsubscribe(aq)
+            vq.put_nowait(None) if not vq.full() else None
+            shutil.rmtree(tmp, ignore_errors=True)
+
     def _handle_stream(self, job_id):
         """Serve an already-downloaded job's file with real HTTP range
         support, so a <video> tag can seek/scrub instead of just
@@ -2396,7 +2509,7 @@ class StreamOnlyHandler(Handler):
     it next to a --tls UI doesn't quietly reopen the whole control
     surface over plain HTTP. Auth, if on, applies exactly as on the main
     port (a player uses ?token=)."""
-    _ALLOWED = ('/api/orbit-view', '/api/orbit-audio', '/api/orbit-stream')
+    _ALLOWED = ('/api/orbit-view', '/api/orbit-audio', '/api/orbit-mux', '/api/orbit-stream')
 
     def do_GET(self):
         path = urlparse(self.path).path

{weed_cli-2.6.2 → weed_cli-2.7.1}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 2.6.2
+Version: 2.7.1
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal
@@ -56,6 +56,7 @@ output (not simulated) — see [Status](#status) for what's verified.
   - [Interactive shell](#interactive-shell)
   - [Web UI](#web-ui)
   - [Orbit Visualizer](#orbit-visualizer)
+  - [Kodi add-on](#kodi-add-on)
   - [Orbit Visualizer plugins](#orbit-visualizer-plugins)
   - [Docker](#docker)
 - [Core mechanisms](#core-mechanisms)
@@ -225,7 +226,7 @@ The player's 🌀 button opens the **Orbit Visualizer**: a canvas driven by
 the track's audio (Web Audio analyser) and a low-res sample of its
 picture. Eleven built-in modes — Tunnel, Bars, Mirror, Scope, Spiral,
 Pixels, ASCII (six character sets, natural or neon), Plasma, Kaleido,
-Particles, Freefall — plus the seventeen in `web/orbit_extras.js` (next
+Particles, Freefall — plus the nineteen in `web/orbit_extras.js` (next
 section). Click the lit mode again for the plain video. Speed, React and
 Zoom retune every mode; every setting persists in the browser.
 
@@ -255,6 +256,11 @@ Zoom retune every mode; every setting persists in the browser.
   guest party page shows a 🔊 listen button; VLC takes both with
   `vlc --demux=mjpeg <view-url> --input-slave=<audio-url>`; OBS takes the
   audio URL as a second Media Source. Safari/iOS can't play WebM audio.
+  With ffmpeg on the node (the Docker image has it; otherwise
+  `$WEED_FFMPEG` or PATH), `/api/orbit-mux` is picture and audio as one
+  live Matroska stream, stream-copied, no transcoding -- for Kodi and
+  anything else that can't pair two URLs. Roku still can't: it wants
+  H.264, and this is MJPEG in a box.
 - **MIDI** (🎹): an AKAI MPK mini or any Web MIDI controller
   (Chrome/Edge/Firefox). Pads pick modes and fire actions, knobs turn
   the sliders or sweep through modes/transitions/character sets;
@@ -279,6 +285,13 @@ Zoom retune every mode; every setting persists in the browser.
   tagged" pick in the pool row limits the draw to one tag. The ☑
   button beside the toggle unfolds a checkbox per mode: untick the ones
   Autopilot should leave alone (they stay a click or a pad away).
+- **Crossfader** (⇆ in the transport bar, or the MIDI panel's Crossfader
+  row): cues the next track -- the queue's next, else Autopilot's pick --
+  on a second hidden deck and fades to it, equal-power on the sound and
+  opacity on the picture; the far end of the fader makes it the track
+  with no gap. The fader stays where it landed and the next fade runs
+  the other way, as on a DJ mixer, so a knob left at an end never
+  commits by accident. A track ending mid-cue jumps to the cued one.
 - **Video swap** (⇄ on the player): another download's picture stands
   in for the current track's — for an mp3 or a static-image video, so
   the visuals have real footage. Audio stays with the track; the
@@ -286,6 +299,36 @@ Zoom retune every mode; every setting persists in the browser.
   slider in the picker, and the pairing is remembered per track. The
   picker has a search box for big libraries.
 
+### Kodi add-on
+
+`kodi/plugin.video.weed` is a Kodi add-on (Kodi 19 Matrix or later, any
+platform) that puts the node on a TV without streaming anything: it
+browses the node over the same web API the browser uses and plays the
+downloaded files through Kodi's own player, which handles every codec.
+Screens: **Downloads** (newest first, extensions dropped), **Playlists**
+with play-all, **Tags** as folders, **Party** (the vote list, select to
++1), **Autopilot** (the node's weighted least-played pick), and the
+**live Orbit feed** while the visualizer is streaming: picture and audio
+together (`/api/orbit-mux`, needs ffmpeg on the node), or the picture or
+the audio alone (the audio one lights up Kodi's own visualisers). Plays are counted on
+the node like the browser's.
+
+```bash
+make kodi                                  # -> dist/plugin.video.weed-<ver>.zip
+```
+
+On the Kodi box: Settings → Add-ons → *Unknown sources* on → *Install
+from zip file* → the zip (copy it over, or share it with the node's
+`/share`). Then open the add-on's settings and set the node URL, for
+example `http://192.168.1.137:8080`, and the token if the node runs with
+`--auth-token`. The add-on hands Kodi the `/api/stream/<job_id>` URLs
+with the token in the query, so seeking and resume work as for any file.
+An https node works too: the add-on accepts the node's self-signed
+certificate for its API calls (a setting, on by default), and sends the
+player to the plain stream port the node advertises
+(`--stream-plain-port`), falling back to https with Kodi's own
+`verifypeer=false` URL option when there is no plain port.
+
 ### Orbit Visualizer plugins
 
 The visualizer's modes and its Fade transitions are both open registries:
@@ -299,10 +342,12 @@ mode selector; a registered transition gets a Fade option and a turn in
 taking the draw loop down. `web/orbit_extras.js` (loaded by default) is
 built entirely on that API and adds Halftone, Lava, Terrain, Rain,
 Lissajous, Vinyl 33, Cube, VHS, Win95, Joy Division, Spectrogram, Stained
-glass, Fireworks, Screensaver, Slit-scan, Skyline and Globe, plus the
-Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom blur, RGB split, VHS,
-Win95, Blinds, Flip tiles, CRT off, Droplet, Blur, Slide and Flash
-transitions (Globe's coastlines are Natural Earth's public-domain 110m
+glass, Fireworks, Screensaver, Slit-scan, Skyline, Globe, Starfield,
+Spectrum 3D, Brain and Arcade, plus the Melt, Dissolve, Iris, Shatter, Wave, Spin, Zoom
+blur, RGB split, VHS, Win95, Blinds, Flip tiles, CRT off, Droplet, Blur,
+Slide, Flash, Desktop cube, Carousel and Doors transitions (the 3D ones
+draw perspective faces as runs of affine strips, since Canvas 2D has no
+projection of its own; Globe's coastlines are Natural Earth's public-domain 110m
 land set, simplified into `web/land.json`); `web/orbit_plugin_example.js`
 is a minimal one to copy.
 
@@ -523,7 +568,10 @@ just designed:
 - Kademlia DHT discovery, survives the announcing node going offline
 - Local web UI with live progress, QR onboarding, HTTP range streaming,
   optional two-tier token auth, and the guest party page with voting
-- Orbit Visualizer: 28 modes and 23 transitions behind a plugin API,
+- Kodi add-on (`kodi/plugin.video.weed`): downloads, playlists, tags,
+  party votes, Autopilot pick and the live feeds on a TV through Kodi's
+  own player, 9 tests against a real node with Kodi stubbed.
+- Orbit Visualizer: 30 modes and 26 transitions behind a plugin API,
   MJPEG network stream (VLC/Roku), Web MIDI control with keymap files,
   video swap — 44 Playwright tests against real Chromium (`tests/e2e/`)
 - Containerized node (`Dockerfile.node`, `docker-compose.node.yml`),

{weed_cli-2.6.2 → weed_cli-2.7.1}/weed_cli.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ weed.py
 tests/test_dht.py
 tests/test_discovery_relay.py
 tests/test_host_live_reload.py
+tests/test_kodi_addon.py
 tests/test_node_manifest.py
 tests/test_orbit_audio.py
 tests/test_orbit_ws.py