weed-cli 1.8.7__tar.gz → 1.9.3__tar.gz

{weed_cli-1.8.7 → weed_cli-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.8.7
+Version: 1.9.3
 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

{weed_cli-1.8.7 → weed_cli-1.9.3}/node.py

@@ -234,16 +234,15 @@ def load_manifest_entries(archive_dir, file_name=None):
     no --file only ever served the single most-recently-added file out of a
     45-video archive. Dedupes by name (last-write-wins, same convention).
 
-    Only 'video' entries are returned. Hosting depends on chunk data
-    (load_leaves) and per-chunk byte math (entry['chunk_size']), and ott
-    only ever writes either for video-type entries — everything else
-    (photos, or any file whose extension ott's is_video() doesn't
-    recognize, which is also where a plain .mp3 lands, since ott only has
-    two types) has chunk_size: None and no .ott/chunks/<hash>.json at all.
-    Filtering here, the one function every hosting path (weed.py,
-    shell.py, web_ui.py) goes through, means one non-video file sitting
-    in an archive_dir no longer poison-pills hosting everything else in
-    it with 'no chunks file at ...'."""
+    Only 'video' and 'audio' entries are returned. Hosting depends on
+    chunk data (load_leaves) and per-chunk byte math (entry['chunk_size']),
+    and ott only ever writes either for video/audio-type entries (see its
+    own cmd_add) — everything else (photos, or any file whose extension
+    ott's is_video()/is_audio() don't recognize) has chunk_size: None and
+    no .ott/chunks/<hash>.json at all. Filtering here, the one function
+    every hosting path (weed.py, shell.py, web_ui.py) goes through, means
+    one non-chunked file sitting in an archive_dir no longer poison-pills
+    hosting everything else in it with 'no chunks file at ...'."""
     archive_dir = os.path.expanduser(archive_dir)
     manifest_path = os.path.join(archive_dir, '.ott', 'manifest.jsonl')
     if not os.path.exists(manifest_path):
@@ -256,14 +255,14 @@ def load_manifest_entries(archive_dir, file_name=None):
     for e in raw:
         by_name[e['name']] = e
     all_entries = list(by_name.values())
-    entries = [e for e in all_entries if e.get('type') == 'video']
+    entries = [e for e in all_entries if e.get('type') in ('video', 'audio')]
     if not entries:
         if all_entries:
             n = len(all_entries)
-            sys.exit(f"no hostable video file found in {archive_dir}" +
+            sys.exit(f"no hostable video/audio file found in {archive_dir}" +
                      (f" matching {file_name}" if file_name else "") +
-                     f" — found {n} non-video entr{'y' if n == 1 else 'ies'} "
-                     f"(only video files can be hosted; see ott's is_video())")
+                     f" — found {n} other entr{'y' if n == 1 else 'ies'} "
+                     f"(only video/audio files can be hosted; see ott's is_video()/is_audio())")
         sys.exit(f"no archived file found in {archive_dir}" + (f" matching {file_name}" if file_name else ""))
     return entries
 

{weed_cli-1.8.7 → weed_cli-1.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "1.8.7"
+version = "1.9.3"
 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-1.8.7 → weed_cli-1.9.3}/tests/test_node_manifest.py

@@ -19,23 +19,46 @@ def test_load_manifest_entries_single_video(tmp_path):
 
 
 def test_load_manifest_entries_filters_non_video(tmp_path):
-    """The actual bug: an mp3 (typed 'image' by ott's extension-based
-    is_video()) sitting in the same archive_dir used to poison-pill
-    hosting the whole directory -- host <dir> with no --file should just
-    skip it and host the real video."""
+    """The original bug this filter exists for: a non-chunked file
+    (originally an mp3, back when ott's extension-based is_video() typed
+    it 'image' for lack of any 'audio' type at all -- see
+    test_load_manifest_entries_includes_audio_alongside_video below for
+    that no longer being true) sitting in the same archive_dir used to
+    poison-pill hosting the whole directory -- host <dir> with no --file
+    should just skip a genuinely non-hostable entry (a real photo, here)
+    and host the real video."""
     video = make_fake_archive(tmp_path, name='good.mp4')
-    make_fake_archive(tmp_path, name='song.mp3', video=False)
+    make_fake_archive(tmp_path, name='photo.jpg', content_type='image')
 
     entries = node.load_manifest_entries(str(tmp_path))
     assert [e['sha256'] for e in entries] == [video['sha256']]
 
 
+def test_load_manifest_entries_includes_audio_alongside_video(tmp_path):
+    """Real ask: support audio (mp3, etc.) in addition to video. ott's
+    own cmd_add now chunks audio the same way it always has video (see
+    its own is_audio()), so an audio-typed manifest entry has real chunk
+    data too -- this is the one place every hosting path (weed.py,
+    shell.py, web_ui.py) filters on 'is this actually hostable', and it
+    needs to say yes to both now, not just video."""
+    video = make_fake_archive(tmp_path, name='good.mp4')
+    audio = make_fake_archive(tmp_path, name='song.mp3', content_type='audio')
+
+    entries = node.load_manifest_entries(str(tmp_path))
+    assert {e['sha256'] for e in entries} == {video['sha256'], audio['sha256']}
+    # the audio entry got real chunk data, not the image-style single
+    # whole-file hash with no chunks
+    audio_entry = next(e for e in entries if e['sha256'] == audio['sha256'])
+    assert audio_entry['n_chunks'] > 1
+    assert node.load_leaves(str(tmp_path), audio['sha256']) is not None
+
+
 def test_load_manifest_entries_explicit_non_video_file_errors_clearly(tmp_path):
     make_fake_archive(tmp_path, name='good.mp4')
-    make_fake_archive(tmp_path, name='song.mp3', video=False)
+    make_fake_archive(tmp_path, name='photo.jpg', content_type='image')
 
-    with pytest.raises(SystemExit, match='no hostable video file found'):
-        node.load_manifest_entries(str(tmp_path), 'song.mp3')
+    with pytest.raises(SystemExit, match='no hostable video/audio file found'):
+        node.load_manifest_entries(str(tmp_path), 'photo.jpg')
 
 
 def test_load_manifest_entries_no_manifest_at_all(tmp_path):

{weed_cli-1.8.7 → weed_cli-1.9.3}/tests/test_web_ui_api.py

@@ -201,10 +201,31 @@ def test_upload_rejects_non_video_extension(web_server, tmp_path):
     archive_dir = str(tmp_path / 'archive')
     status, resp = http_post_raw(_upload_url(web_server, 'notes.txt', archive_dir), b'hello')
     assert status == 400
-    assert 'not a recognized video extension' in resp['error']
+    assert 'not a recognized video or audio extension' in resp['error']
     assert not os.path.exists(archive_dir)  # never even created
 
 
+def test_upload_audio_produces_a_real_hostable_archive(web_server, tmp_path):
+    """Real ask: support audio (mp3, etc.) in addition to video --
+    uploading one should archive it exactly like a video does (real
+    chunk data, type: 'audio'), not get rejected the way it used to
+    before ott/node.py recognized audio as its own hostable type."""
+    archive_dir = str(tmp_path / 'archive')
+    data = os.urandom(200_000)
+    status, resp = http_post_raw(_upload_url(web_server, 'song.mp3', archive_dir), data)
+
+    assert status == 200
+    assert resp['ok'] is True
+    assert resp['type'] == 'audio'
+    assert resp['n_chunks'] >= 1
+
+    entries = node.load_manifest_entries(archive_dir)
+    assert len(entries) == 1
+    assert entries[0]['type'] == 'audio'
+    leaves = node.load_leaves(archive_dir, resp['content_hash'])
+    assert len(leaves) == resp['n_chunks']
+
+
 def test_upload_sanitizes_path_traversal_in_filename(web_server, tmp_path):
     archive_dir = str(tmp_path / 'archive')
     outside_target = tmp_path / 'evil.mp4'

{weed_cli-1.8.7 → weed_cli-1.9.3}/tests/testutil.py

@@ -89,15 +89,22 @@ def _split_url(url):
     return host, int(port), '/' + path
 
 
-def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_536, video=True):
+def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_536, video=True,
+                       content_type=None):
     """Hand-writes a minimal but real .ott/manifest.jsonl + chunks file --
     real sha256 chunk hashes and a real merkle root via the same ott
     helpers node.py itself calls, just skipping ott's own add/stage/commit
     workflow (irrelevant to what node.py/web_ui.py actually read: the
-    final manifest.jsonl + chunks/<hash>.json shape). video=False produces
-    an 'image'-typed entry with no chunks file, for regression-testing the
-    mp3/photo-mixed-into-an-archive fix (load_manifest_entries filtering
-    to video-only)."""
+    final manifest.jsonl + chunks/<hash>.json shape).
+
+    content_type overrides video/False entirely when given ('video',
+    'audio', or 'image') -- video=True/False is kept as the original
+    shorthand for the two cases every existing test already uses.
+    'image' (or any other non-chunkable type) produces no chunks file,
+    for regression-testing the photo-mixed-into-an-archive fix
+    (load_manifest_entries filtering to video/audio only); 'video' and
+    'audio' both get real chunk data, same as ott's own cmd_add does for
+    either since a bare mp3 stopped being lumped in with 'image'."""
     os.makedirs(archive_dir, exist_ok=True)
     ott_dir = os.path.join(archive_dir, '.ott')
     os.makedirs(os.path.join(ott_dir, 'chunks'), exist_ok=True)
@@ -105,12 +112,16 @@ def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_
     with open(file_path, 'wb') as f:
         f.write(os.urandom(size))
 
-    if video:
+    if content_type is None:
+        content_type = 'video' if video else 'image'
+    chunkable = content_type in ('video', 'audio')
+
+    if chunkable:
         chunks = chunk_hashes(file_path, chunk_size)
         digest = merkle_root(chunks)
         entry = {
             'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
-            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': 'video',
+            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': content_type,
             'n_chunks': len(chunks), 'chunk_size': chunk_size,
         }
         with open(os.path.join(ott_dir, 'chunks', f'{digest}.json'), 'w') as f:
@@ -119,7 +130,7 @@ def make_fake_archive(archive_dir, name='clip.mp4', size=200_000, chunk_size=65_
         digest = hashlib.sha256(open(file_path, 'rb').read()).hexdigest()
         entry = {
             'sha256': digest, 'name': name, 'orig_path': name, 'last_path': file_path,
-            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': 'image',
+            'size': size, 'added': '2026-01-01T00:00:00Z', 'type': content_type,
             'n_chunks': 1, 'chunk_size': None,
         }
 

{weed_cli-1.8.7 → weed_cli-1.9.3}/web_ui.py

@@ -746,12 +746,13 @@ class Handler(BaseHTTPRequestHandler):
         with no separate `ott add` step -- same reasoning as the rest of
         this UI existing at all: don't make someone learn a second tool
         just to do the thing this one already knows how to do.
-        Video-only, matching ott's own is_video() -- a non-video upload
-        would just be a manifest entry that can never actually be
-        hosted (see load_manifest_entries' own video-only filter, added
-        after exactly that silently broke `host` for everything else in
-        the same archive_dir), so it's rejected up front instead."""
-        from ott import is_video, chunk_hashes, merkle_root, OttStore
+        Video or audio, matching ott's own is_video()/is_audio() -- an
+        upload of neither would just be a manifest entry that can never
+        actually be hosted (see load_manifest_entries' own video/audio-
+        only filter, added after exactly that silently broke `host` for
+        everything else in the same archive_dir), so it's rejected up
+        front instead."""
+        from ott import is_video, is_audio, chunk_hashes, merkle_root, OttStore
 
         qs = parse_qs(urlparse(self.path).query)
         raw_name = (qs.get('name') or [''])[0]
@@ -765,10 +766,15 @@ class Handler(BaseHTTPRequestHandler):
         if not safe_name or safe_name in ('.', '..'):
             return self._json({'error': f'invalid file name: {raw_name!r}'}, status=400)
 
-        if not is_video(safe_name):
+        if is_video(safe_name):
+            content_type = 'video'
+        elif is_audio(safe_name):
+            content_type = 'audio'
+        else:
             return self._json(
-                {'error': f'{safe_name}: not a recognized video extension -- only video '
-                           'files can be hosted (see ott.is_video)'}, status=400)
+                {'error': f'{safe_name}: not a recognized video or audio extension -- only '
+                           'video/audio files can be hosted (see ott.is_video/ott.is_audio)'},
+                status=400)
 
         archive_dir = os.path.expanduser(archive_dir)
         os.makedirs(archive_dir, exist_ok=True)
@@ -814,7 +820,7 @@ class Handler(BaseHTTPRequestHandler):
         entry = {
             'sha256': digest, 'name': safe_name, 'orig_path': safe_name, 'last_path': dest_path,
             'size': written, 'added': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
-            'type': 'video', 'n_chunks': len(chunks), 'chunk_size': chunk_size,
+            'type': content_type, 'n_chunks': len(chunks), 'chunk_size': chunk_size,
         }
 
         # _lock (not just for _jobs/_hosts/_library, see its own comment
@@ -857,7 +863,7 @@ class Handler(BaseHTTPRequestHandler):
                 f.write(existing + json.dumps(entry) + '\n')
             os.replace(manifest_tmp, manifest_path)
 
-        self._json({'ok': True, 'name': safe_name, 'content_hash': digest,
+        self._json({'ok': True, 'name': safe_name, 'content_hash': digest, 'type': content_type,
                      'size': written, 'n_chunks': len(chunks), 'archive_dir': archive_dir})
 
     def _handle_host(self, body):

{weed_cli-1.8.7 → weed_cli-1.9.3}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.8.7
+Version: 1.9.3
 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