fix: fix youtube video reading (#5126)

## Changes Made

YouTube streaming was not working, and the example in the docs was
broken. This is a dumber but more robust approach to downloading and
processing youtube videos.

## Related Issues

n/a

## Checklist

- [x] Documented in API Docs (if applicable)
- [x] Documented in User Guide (if applicable)
- [x] If adding a new documentation page, doc is added to
`docs/mkdocs.yml` navigation
- [x] Documentation builds and is formatted properly (tag @/ccmao1130
for docs review)

---------

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

Author: rchowell

daft/io/av/_read_video_frames.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import os
+import tempfile
+from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 from urllib.parse import urlparse
@@ -131,6 +134,7 @@ def schema(self) -> Schema:
         )
 
     def _list_frames(self, path: str, file: Any) -> Generator[_VideoFrame]:
+        container = None
         try:
             container = av.open(file)
 
@@ -147,8 +151,6 @@ def _list_frames(self, path: str, file: Any) -> Generator[_VideoFrame]:
                     frame = next(container.decode(stream))
                 except StopIteration:
                     break
-                except Exception:
-                    continue  # skip decoding errors
 
                 if self.is_key_frame is not None and self.is_key_frame != frame.key_frame:
                     continue  # skip based on is_key_frame filter
@@ -171,28 +173,70 @@ def _list_frames(self, path: str, file: Any) -> Generator[_VideoFrame]:
                 )
                 frame_index += 1
         finally:
-            container.close()
+            if container:
+                container.close()
 
     def _open(self) -> Any:
         if _is_youtube_url(self.path):
-            import requests
-            import yt_dlp
-
-            with yt_dlp.YoutubeDL({"format": "mp4", "quiet": True}) as ydl:
-                info = ydl.extract_info(self.path, download=False)
-                if "url" in info:
-                    direct_url = info["url"]
-                elif "entries" in info and len(info["entries"]) > 0 and "url" in info["entries"][0]:
-                    direct_url = info["entries"][0]["url"]
-                else:
-                    raise ValueError("Could not extract URL from youtube video.")
-                response = requests.get(direct_url, stream=True)
-                response.raise_for_status()
-                return response.raw
+            return self._open_youtube_file()
         else:
             fp, fs, _ = _infer_filesystem(self.path, io_config=self.io_config)
             return fs.open_input_file(fp)
 
+    @contextmanager
+    def _open_youtube_file(self) -> Any:
+        import yt_dlp
+
+        def selector(ctx):  # type: ignore
+            best_fmt = None
+            best_fit = float("inf")  # lower is better
+
+            for fmt in ctx["formats"]:
+                if fmt.get("ext") != "mp4":
+                    continue
+
+                h, w = fmt.get("height"), fmt.get("width")
+                if h is None or w is None:
+                    continue
+
+                fit = abs(h - self.image_height) + abs(w - self.image_width)
+                if fit == 0:
+                    yield fmt
+                    return
+                if fit < best_fit:
+                    best_fmt = fmt
+                    best_fit = fit
+
+            yield best_fmt
+
+        # Note:
+        #   Streaming youtube downloads requires deeper work and was error-prone.
+        #   The parsed youtube urls use m3u8 which requires decoding which ydl
+        #   will handle for us. We cannot reliable pass a file-like HTTP response
+        #   to PyAV; hence why this will download to a tempfile then open the file.
+
+        temp_file = next(tempfile._get_candidate_names())  # type: ignore
+
+        params = {
+            "format": selector,
+            "quiet": True,
+            "outtmpl": temp_file,
+            "no_warnings": True,
+            "extract_flat": False,
+            "no_check_certificate": True,
+            "ignoreerrors": False,
+            "consoletitle": False,
+            "noprogress": True,
+        }
+
+        try:
+            with yt_dlp.YoutubeDL(params) as ydl:
+                ydl.download([self.path])
+            yield open(temp_file, mode="rb")
+        finally:
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+
     def get_micro_partitions(self) -> Iterator[MicroPartition]:
         with self._open() as file:
             buffer = _VideoFramesBuffer(

docs/modalities/videos.md

@@ -57,11 +57,47 @@ This example shows reading a video's frames into a DataFrame.
 
 This example shows reading the key frames of a youtube video, you can also pass in a list of video urls.
 
-```python
-df = daft.read_video_frames(
-    path="https://www.youtube.com/watch?v=jNQXAC9IVRw",
-    image_height=480,
-    image_width=640,
-    is_key_frame=True,
-)
+=== "🐍 Python"
+
+    ```python
+    import daft
+
+    df = daft.read_video_frames(
+        path=[
+            "https://www.youtube.com/watch?v=jNQXAC9IVRw",
+            "https://www.youtube.com/watch?v=N2rZxCrb7iU",
+            "https://www.youtube.com/watch?v=TF6cnLnEARo",
+        ],
+        image_height=480,
+        image_width=640,
+        is_key_frame=True,
+    )
+
+    df.show()
+    ```
+
+```{title="Output"}
+╭────────────────────────────────┬─────────────┬───────────────────┬─────────────────┬───────────┬───────────┬────────────────┬──────────────┬───────────────────────╮
+│ path                           ┆ frame_index ┆ frame_time        ┆ frame_time_base ┆ frame_pts ┆ frame_dts ┆ frame_duration ┆ is_key_frame ┆ data                  │
+│ ---                            ┆ ---         ┆ ---               ┆ ---             ┆ ---       ┆ ---       ┆ ---            ┆ ---          ┆ ---                   │
+│ Utf8                           ┆ Int64       ┆ Float64           ┆ Utf8            ┆ Int64     ┆ Int64     ┆ Int64          ┆ Boolean      ┆ Image[RGB; 480 x 640] │
+╞════════════════════════════════╪═════════════╪═══════════════════╪═════════════════╪═══════════╪═══════════╪════════════════╪══════════════╪═══════════════════════╡
+│ https://www.youtube.com/watch… ┆ 0           ┆ 0                 ┆ 1/90000         ┆ 0         ┆ 0         ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 1           ┆ 6.8068            ┆ 1/90000         ┆ 612612    ┆ 612612    ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 2           ┆ 13.2132           ┆ 1/90000         ┆ 1189188   ┆ 1189188   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 3           ┆ 18.018            ┆ 1/90000         ┆ 1621620   ┆ 1621620   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 4           ┆ 24.8248           ┆ 1/90000         ┆ 2234232   ┆ 2234232   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 5           ┆ 30.03             ┆ 1/90000         ┆ 2702700   ┆ 2702700   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 6           ┆ 36.36966666666667 ┆ 1/90000         ┆ 3273270   ┆ 3273270   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+│ https://www.youtube.com/watch… ┆ 7           ┆ 43.27656666666667 ┆ 1/90000         ┆ 3894891   ┆ 3894891   ┆ 3003           ┆ true         ┆ <FixedShapeImage>     │
+╰────────────────────────────────┴─────────────┴───────────────────┴─────────────────┴───────────┴───────────┴────────────────┴──────────────┴───────────────────────╯
+
+(Showing first 8 rows)
 ```