150 lines
4.9 KiB
Python
150 lines
4.9 KiB
Python
from typing import Dict
|
|
from typing import List
|
|
|
|
from ytdl_sub.downloaders.youtube_downloader import YoutubeDownloader
|
|
from ytdl_sub.downloaders.youtube_downloader import YoutubePlaylistDownloaderOptions
|
|
from ytdl_sub.entries.youtube import YoutubeVideo
|
|
from ytdl_sub.utils.chapters import Chapters
|
|
from ytdl_sub.utils.chapters import Timestamp
|
|
from ytdl_sub.utils.ffmpeg import add_ffmpeg_metadata
|
|
from ytdl_sub.validators.validators import BoolValidator
|
|
|
|
###############################################################################
|
|
# Youtube split video downloader + options
|
|
|
|
|
|
class YoutubeMergePlaylistDownloaderOptions(YoutubePlaylistDownloaderOptions):
|
|
"""
|
|
Downloads all videos in a playlist and merges them into a single video.
|
|
|
|
Usage:
|
|
|
|
.. code-block:: yaml
|
|
|
|
presets:
|
|
example_preset:
|
|
youtube:
|
|
# required
|
|
download_strategy: "merge_playlist"
|
|
playlist_url: "TODO"
|
|
# optional
|
|
add_chapters: False
|
|
|
|
CLI usage:
|
|
|
|
.. code-block:: bash
|
|
|
|
ytdl-sub dl \
|
|
--preset "example_preset" \
|
|
--youtube.video_url "youtube.com/watch?v=VMAPTo7RVDo" \
|
|
--youtube.split_timestamps "path/to/timestamps.txt"
|
|
|
|
``split_timestamps`` file format:
|
|
|
|
.. code-block:: markdown
|
|
|
|
0:00 Intro
|
|
0:24 Blackwater Park
|
|
10:23 Bleak
|
|
16:39 Jokes
|
|
1:02:23 Ending
|
|
|
|
The above will create 5 videos in total. The first timestamp must start with ``0:00``
|
|
and the last timestamp, in this example, would create a video starting at ``1:02:23`` and
|
|
end at Youtube video's ending.
|
|
"""
|
|
|
|
_required_keys = {"playlist_url"}
|
|
_optional_keys = {"add_chapters"}
|
|
|
|
def __init__(self, name, value):
|
|
super().__init__(name, value)
|
|
self._add_chapters = self._validate_key_if_present(
|
|
"add_chapters", validator=BoolValidator, default=False
|
|
).value
|
|
|
|
@property
|
|
def add_chapters(self) -> bool:
|
|
"""
|
|
Whether to add chapters using each video's title in the merged playlist. Defaults to false.
|
|
"""
|
|
return self._add_chapters
|
|
|
|
|
|
class YoutubeMergePlaylistDownloader(
|
|
YoutubeDownloader[YoutubeMergePlaylistDownloaderOptions, YoutubeVideo]
|
|
):
|
|
downloader_options_type = YoutubeMergePlaylistDownloaderOptions
|
|
downloader_entry_type = YoutubeVideo
|
|
supports_download_archive = False
|
|
|
|
@classmethod
|
|
def ytdl_option_defaults(cls) -> Dict:
|
|
"""
|
|
Default `ytdl_options`_ for ``split_video``
|
|
|
|
.. code-block:: yaml
|
|
|
|
ytdl_options:
|
|
ignoreerrors: True # ignore errors like hidden videos, age restriction, etc
|
|
"""
|
|
return dict(
|
|
super().ytdl_option_defaults(),
|
|
**{
|
|
"playlistreverse": True,
|
|
"postprocessors": [
|
|
{
|
|
"key": "FFmpegVideoConvertor",
|
|
"when": "post_process",
|
|
"preferedformat": "mkv",
|
|
},
|
|
{
|
|
"key": "FFmpegConcat",
|
|
"when": "playlist",
|
|
},
|
|
],
|
|
},
|
|
)
|
|
|
|
def _add_chapters(self, merged_video: YoutubeVideo) -> None:
|
|
titles: List[str] = []
|
|
timestamps: List[Timestamp] = []
|
|
|
|
current_timestamp_sec = 0
|
|
for video_entry in merged_video.kwargs("entries"):
|
|
timestamps.append(Timestamp(current_timestamp_sec))
|
|
titles.append(video_entry["title"])
|
|
|
|
current_timestamp_sec += video_entry["duration"]
|
|
|
|
add_ffmpeg_metadata(
|
|
file_path=merged_video.get_download_file_path(),
|
|
chapters=Chapters(timestamps=timestamps, titles=titles),
|
|
file_duration_sec=merged_video.kwargs("duration"),
|
|
)
|
|
|
|
def _to_merged_video(self, entry_dict: Dict) -> YoutubeVideo:
|
|
"""
|
|
Adds a few entries not included in a playlist entry to make it look like a merged video
|
|
entry_dict
|
|
"""
|
|
# Set the upload date to be the latest playlist video date
|
|
entry_dict["upload_date"] = max(
|
|
playlist_entry["upload_date"] for playlist_entry in entry_dict["entries"]
|
|
)
|
|
entry_dict["duration"] = sum(
|
|
playlist_entry["duration"] for playlist_entry in entry_dict["entries"]
|
|
)
|
|
entry_dict["ext"] = entry_dict["requested_downloads"][0]["ext"]
|
|
return YoutubeVideo(entry_dict=entry_dict, working_directory=self.working_directory)
|
|
|
|
def download(self) -> List[YoutubeVideo]:
|
|
"""Download a single Youtube video, then split it into multiple videos"""
|
|
merged_video = self._to_merged_video(
|
|
entry_dict=self.extract_info(url=self.download_options.playlist_url)
|
|
)
|
|
|
|
if self.download_options.add_chapters:
|
|
self._add_chapters(merged_video=merged_video)
|
|
|
|
return [merged_video]
|