Bumped version

* Moved quality options to their own module

* Added language and format selection to quality option builder

* [WIP] migrating tests

* Added audio_lang to media_profile table

* Renamed column; added format options and tests

* Adds UI for audio_track to the media profile form

* Adds a version string to in-app streams to help with cache busting

assets/js/alpine_helpers.js

@@ -35,3 +35,10 @@ window.markVersionAsSeen = (versionString) => {
 window.isVersionSeen = (versionString) => {
   return localStorage.getItem('seenVersion') === versionString
 }
+
+window.dispatchFor = (elementOrId, eventName, detail = {}) => {
+  const element =
+    typeof elementOrId === 'string' ? document.getElementById(elementOrId) : elementOrId
+
+  element.dispatchEvent(new CustomEvent(eventName, { detail }))
+}

assets/js/app.js

@@ -39,7 +39,7 @@ let liveSocket = new LiveSocket(document.body.dataset.socketPath, Socket, {
     }
   },
   hooks: {
-    supressEnterSubmission: {
+    'supress-enter-submission': {
       mounted() {
         this.el.addEventListener('keypress', (event) => {
           if (event.key === 'Enter') {
@@ -47,6 +47,29 @@ let liveSocket = new LiveSocket(document.body.dataset.socketPath, Socket, {
           }
         })
       }
+    },
+    'formless-input': {
+      mounted() {
+        const subscribedEvents = this.el.dataset.subscribe.split(' ')
+        const eventName = this.el.dataset.eventName || ''
+        const identifier = this.el.dataset.identifier || ''
+
+        subscribedEvents.forEach((domEvent) => {
+          this.el.addEventListener(domEvent, () => {
+            // This ensures that the event is pushed to the server after the input value has been updated
+            // so that the server has the most up-to-date value
+            setTimeout(() => {
+              this.pushEvent('formless-input', {
+                value: this.el.value,
+                id: identifier,
+                event: eventName,
+                dom_id: this.el.id,
+                dom_event: domEvent
+              })
+            }, 0)
+          })
+        })
+      }
     }
   }
 })

docker/selfhosted.Dockerfile

@@ -88,6 +88,7 @@ RUN apt-get update -y && \
       ca-certificates \
       python3-mutagen \
       curl \
+      zip \
       openssh-client \
       nano \
       python3 \
@@ -116,7 +117,8 @@ ENV LC_ALL en_US.UTF-8
 WORKDIR "/app"
 
 # Set up data volumes
-RUN mkdir /config /downloads /etc/elixir_tzdata_data && chmod ugo+rw /etc/elixir_tzdata_data
+RUN mkdir -p /config /downloads /etc/elixir_tzdata_data /etc/yt-dlp/plugins && \ 
+  chmod ugo+rw /etc/elixir_tzdata_data /etc/yt-dlp /etc/yt-dlp/plugins
 
 # set runner ENV
 ENV MIX_ENV="prod"

lib/pinchflat/boot/pre_job_startup_tasks.ex

@@ -16,6 +16,8 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
   alias Pinchflat.Settings
   alias Pinchflat.Utils.FilesystemUtils
 
+  alias Pinchflat.Lifecycle.UserScripts.CommandRunner, as: UserScriptRunner
+
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, %{}, opts)
   end
@@ -36,6 +38,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
     create_blank_yt_dlp_files()
     create_blank_user_script_file()
     apply_default_settings()
+    run_app_init_script()
 
     {:ok, state}
   end
@@ -95,6 +98,12 @@ defmodule Pinchflat.Boot.PreJobStartupTasks do
     Settings.set(apprise_version: apprise_version)
   end
 
+  defp run_app_init_script do
+    runner = Application.get_env(:pinchflat, :user_script_runner, UserScriptRunner)
+
+    runner.run(:app_init, %{})
+  end
+
   defp yt_dlp_runner do
     Application.get_env(:pinchflat, :yt_dlp_runner)
   end

lib/pinchflat/downloading/download_option_builder.ex

@@ -4,10 +4,10 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   """
 
   alias Pinchflat.Sources
-  alias Pinchflat.Settings
   alias Pinchflat.Sources.Source
   alias Pinchflat.Media.MediaItem
   alias Pinchflat.Downloading.OutputPathBuilder
+  alias Pinchflat.Downloading.QualityOptionBuilder
 
   alias Pinchflat.Utils.FilesystemUtils, as: FSUtils
 
@@ -34,21 +34,38 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
 
   @doc """
   Builds the output path for yt-dlp to download media based on the given source's
-  media profile. Uses the source's override output path template if it exists.
+  or media_item's media profile. Uses the source's override output path template if it exists.
 
   Accepts a %MediaItem{} or %Source{} struct. If a %Source{} struct is passed, it
   will use a default %MediaItem{} struct with the given source.
 
   Returns binary()
   """
+  def build_output_path_for(%Source{} = source_with_preloads) do
+    build_output_path_for(%MediaItem{source: source_with_preloads})
+  end
+
   def build_output_path_for(%MediaItem{} = media_item_with_preloads) do
     output_path_template = Sources.output_path_template(media_item_with_preloads.source)
 
     build_output_path(output_path_template, media_item_with_preloads)
   end
 
-  def build_output_path_for(%Source{} = source_with_preloads) do
-    build_output_path_for(%MediaItem{source: source_with_preloads})
+  @doc """
+  Builds the quality options for yt-dlp to download media based on the given source's
+  or media_item's media profile. Useful for helping predict final filepath of downloaded
+  media.
+
+  returns [Keyword.t()]
+  """
+  def build_quality_options_for(%Source{} = source_with_preloads) do
+    build_quality_options_for(%MediaItem{source: source_with_preloads})
+  end
+
+  def build_quality_options_for(%MediaItem{} = media_item_with_preloads) do
+    media_profile = media_item_with_preloads.source.media_profile
+
+    quality_options(media_profile)
   end
 
   defp default_options(override_opts) do
@@ -125,27 +142,7 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilder do
   end
 
   defp quality_options(media_profile) do
-    vcodec = Settings.get!(:video_codec_preference)
-    acodec = Settings.get!(:audio_codec_preference)
-    container = media_profile.media_container
-
-    case media_profile.preferred_resolution do
-      # Also be aware that :audio disabled all embedding options for subtitles
-      :audio ->
-        [:extract_audio, format_sort: "+acodec:#{acodec}", audio_format: container || "best"]
-
-      resolution_atom ->
-        {resolution_string, _} =
-          resolution_atom
-          |> Atom.to_string()
-          |> Integer.parse()
-
-        [
-          # Since Plex doesn't support reading metadata from MKV
-          remux_video: container || "mp4",
-          format_sort: "res:#{resolution_string},+codec:#{vcodec}:#{acodec}"
-        ]
-    end
+    QualityOptionBuilder.build(media_profile)
   end
 
   defp sponsorblock_options(media_profile) do

lib/pinchflat/downloading/media_download_worker.ex

@@ -94,6 +94,9 @@ defmodule Pinchflat.Downloading.MediaDownloadWorker do
       {:recovered, _} ->
         {:error, :retry}
 
+      {:error, :unsuitable_for_download} ->
+        {:ok, :non_retry}
+
       {:error, message} ->
         action_on_error(message)
     end

lib/pinchflat/downloading/media_downloader.ex

@@ -37,6 +37,13 @@ defmodule Pinchflat.Downloading.MediaDownloader do
       {:ok, parsed_json} ->
         update_media_item_from_parsed_json(media_with_preloads, parsed_json)
 
+      {:error, :unsuitable_for_download} ->
+        Logger.warning(
+          "Media item ##{media_with_preloads.id} isn't suitable for download yet. May be an active or processing live stream"
+        )
+
+        {:error, :unsuitable_for_download}
+
       {:error, message, _exit_code} ->
         Logger.error("yt-dlp download error for media item ##{media_with_preloads.id}: #{inspect(message)}")
 
@@ -108,7 +115,11 @@ defmodule Pinchflat.Downloading.MediaDownloader do
     {:ok, options} = DownloadOptionBuilder.build(item_with_preloads, override_opts)
     runner_opts = [output_filepath: output_filepath, use_cookies: item_with_preloads.source.use_cookies]
 
-    YtDlpMedia.download(url, options, runner_opts)
+    case YtDlpMedia.get_downloadable_status(url) do
+      {:ok, :downloadable} -> YtDlpMedia.download(url, options, runner_opts)
+      {:ok, :ignorable} -> {:error, :unsuitable_for_download}
+      err -> err
+    end
   end
 
   defp recoverable_errors do

lib/pinchflat/downloading/quality_option_builder.ex

@@ -0,0 +1,66 @@
+defmodule Pinchflat.Downloading.QualityOptionBuilder do
+  @moduledoc """
+  A standalone builder module for building quality-related options for yt-dlp to download media.
+
+  Currently exclusively used in DownloadOptionBuilder since this logic is too complex to just
+  place in the main module.
+  """
+
+  alias Pinchflat.Settings
+  alias Pinchflat.Profiles.MediaProfile
+
+  @doc """
+  Builds the quality-related options for yt-dlp to download media based on the given media profile
+
+  Includes things like container, preferred format/codec, and audio track options.
+  """
+  def build(%MediaProfile{preferred_resolution: :audio, media_container: container} = media_profile) do
+    acodec = Settings.get!(:audio_codec_preference)
+
+    [
+      :extract_audio,
+      format_sort: "+acodec:#{acodec}",
+      audio_format: container || "best",
+      format: build_format_string(media_profile)
+    ]
+  end
+
+  def build(%MediaProfile{preferred_resolution: resolution_atom, media_container: container} = media_profile) do
+    vcodec = Settings.get!(:video_codec_preference)
+    acodec = Settings.get!(:audio_codec_preference)
+    {resolution_string, _} = resolution_atom |> Atom.to_string() |> Integer.parse()
+
+    [
+      # Since Plex doesn't support reading metadata from MKV
+      remux_video: container || "mp4",
+      format_sort: "res:#{resolution_string},+codec:#{vcodec}:#{acodec}",
+      format: build_format_string(media_profile)
+    ]
+  end
+
+  defp build_format_string(%MediaProfile{preferred_resolution: :audio, audio_track: audio_track}) do
+    if audio_track do
+      "bestaudio[#{build_format_modifier(audio_track)}]/bestaudio/best"
+    else
+      "bestaudio/best"
+    end
+  end
+
+  defp build_format_string(%MediaProfile{audio_track: audio_track}) do
+    if audio_track do
+      "bestvideo+bestaudio[#{build_format_modifier(audio_track)}]/bestvideo*+bestaudio/best"
+    else
+      "bestvideo*+bestaudio/best"
+    end
+  end
+
+  # Reminder to self: this conflicts with `--extractor-args "youtube:lang=<LANG>"`
+  # since that will translate the format_notes as well, which means they may not match.
+  # At least that's what happens now - worth a re-check if I have to come back to this
+  defp build_format_modifier("original"), do: "format_note*=original"
+  defp build_format_modifier("default"), do: "format_note*='(default)'"
+  # This uses the carat to anchor the language to the beginning of the string
+  # since that's what's needed to match `en` to `en-US` and `en-GB`, etc. The user
+  # can always specify the full language code if they want.
+  defp build_format_modifier(language_code), do: "language^=#{language_code}"
+end

lib/pinchflat/fast_indexing/fast_indexing_helpers.ex

@@ -11,13 +11,27 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
 
   alias Pinchflat.Repo
   alias Pinchflat.Media
+  alias Pinchflat.Tasks
   alias Pinchflat.Sources.Source
   alias Pinchflat.FastIndexing.YoutubeRss
   alias Pinchflat.FastIndexing.YoutubeApi
   alias Pinchflat.Downloading.DownloadingHelpers
+  alias Pinchflat.FastIndexing.FastIndexingWorker
+  alias Pinchflat.Downloading.DownloadOptionBuilder
 
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
 
+  @doc """
+  Kicks off a new fast indexing task for a source. This will delete any existing fast indexing
+  tasks for the source before starting a new one.
+
+  Returns {:ok, %Task{}}
+  """
+  def kickoff_indexing_task(%Source{} = source) do
+    Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
+    FastIndexingWorker.kickoff_with_task(source)
+  end
+
   @doc """
   Fetches new media IDs for a source from YT's API or RSS, indexes them, and kicks off downloading
   tasks for any pending media items. See comments in `FastIndexingWorker` for more info on the
@@ -27,6 +41,10 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
   downloaded_.
   """
   def kickoff_download_tasks_from_youtube_rss_feed(%Source{} = source) do
+    # The media_profile is needed to determine the quality options to _then_ determine a more
+    # accurate predicted filepath
+    source = Repo.preload(source, [:media_profile])
+
     {:ok, media_ids} = get_recent_media_ids(source)
     existing_media_items = list_media_items_by_media_id_for(source, media_ids)
     new_media_ids = media_ids -- Enum.map(existing_media_items, & &1.media_id)
@@ -68,7 +86,11 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpers do
   defp create_media_item_from_media_id(source, media_id) do
     url = "https://www.youtube.com/watch?v=#{media_id}"
 
-    case YtDlpMedia.get_media_attributes(url, use_cookies: source.use_cookies) do
+    command_opts =
+      [output: DownloadOptionBuilder.build_output_path_for(source)] ++
+        DownloadOptionBuilder.build_quality_options_for(source)
+
+    case YtDlpMedia.get_media_attributes(url, command_opts, use_cookies: source.use_cookies) do
       {:ok, media_attrs} ->
         Media.create_media_item_from_backend_attrs(source, media_attrs)
 

lib/pinchflat/lifecycle/user_scripts/command_runner.ex

@@ -12,6 +12,7 @@ defmodule Pinchflat.Lifecycle.UserScripts.CommandRunner do
   @behaviour UserScriptCommandRunner
 
   @event_types [
+    :app_init,
     :media_pre_download,
     :media_downloaded,
     :media_deleted

lib/pinchflat/media/media_item.ex

@@ -31,6 +31,7 @@ defmodule Pinchflat.Media.MediaItem do
     :uploaded_at,
     :upload_date_index,
     :duration_seconds,
+    :predicted_media_filepath,
     # these fields are captured only on download
     :media_downloaded_at,
     :media_filepath,
@@ -76,6 +77,7 @@ defmodule Pinchflat.Media.MediaItem do
     field :duration_seconds, :integer
     field :playlist_index, :integer, default: 0
 
+    field :predicted_media_filepath, :string
     field :media_filepath, :string
     field :media_size_bytes, :integer
     field :thumbnail_filepath, :string

lib/pinchflat/profiles/media_profile.ex

@@ -26,6 +26,7 @@ defmodule Pinchflat.Profiles.MediaProfile do
     sponsorblock_categories
     shorts_behaviour
     livestream_behaviour
+    audio_track
     preferred_resolution
     media_container
     redownload_delay_days
@@ -65,6 +66,7 @@ defmodule Pinchflat.Profiles.MediaProfile do
     # See `build_format_clauses` in the Media context for more.
     field :shorts_behaviour, Ecto.Enum, values: ~w(include exclude only)a, default: :include
     field :livestream_behaviour, Ecto.Enum, values: ~w(include exclude only)a, default: :include
+    field :audio_track, :string
     field :preferred_resolution, Ecto.Enum, values: ~w(4320p 2160p 1080p 720p 480p 360p audio)a, default: :"1080p"
     field :media_container, :string, default: nil
 

lib/pinchflat/profiles/profiles_query.ex

@@ -0,0 +1,29 @@
+defmodule Pinchflat.Profiles.ProfilesQuery do
+  @moduledoc """
+  Query helpers for the Profiles context.
+
+  These methods are made to be one-ish liners used
+  to compose queries. Each method should strive to do
+  _one_ thing. These don't need to be tested as
+  they are just building blocks for other functionality
+  which, itself, will be tested.
+  """
+  import Ecto.Query, warn: false
+
+  alias Pinchflat.Profiles.MediaProfile
+
+  # This allows the module to be aliased and query methods to be used
+  # all in one go
+  # usage: use Pinchflat.Profiles.ProfilesQuery
+  defmacro __using__(_opts) do
+    quote do
+      import Ecto.Query, warn: false
+
+      alias unquote(__MODULE__)
+    end
+  end
+
+  def new do
+    MediaProfile
+  end
+end

lib/pinchflat/release.ex

@@ -29,6 +29,8 @@ defmodule Pinchflat.Release do
       [
         "/config",
         "/downloads",
+        "/etc/yt-dlp",
+        "/etc/yt-dlp/plugins",
         Application.get_env(:pinchflat, :media_directory),
         Application.get_env(:pinchflat, :tmpfile_directory),
         Application.get_env(:pinchflat, :extras_directory),

lib/pinchflat/slow_indexing/slow_indexing_helpers.ex

@@ -16,6 +16,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   alias Pinchflat.YtDlp.MediaCollection
   alias Pinchflat.Downloading.DownloadingHelpers
   alias Pinchflat.SlowIndexing.FileFollowerServer
+  alias Pinchflat.Downloading.DownloadOptionBuilder
   alias Pinchflat.SlowIndexing.MediaCollectionIndexingWorker
 
   alias Pinchflat.YtDlp.Media, as: YtDlpMedia
@@ -24,13 +25,28 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   Starts tasks for indexing a source's media regardless of the source's indexing
   frequency. It's assumed the caller will check for indexing frequency.
 
-  Returns {:ok, %Task{}}.
+  Returns {:ok, %Task{}}
   """
   def kickoff_indexing_task(%Source{} = source, job_args \\ %{}, job_opts \\ []) do
+    job_offset_seconds = calculate_job_offset_seconds(source)
+
     Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
     Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker", include_executing: true)
 
-    MediaCollectionIndexingWorker.kickoff_with_task(source, job_args, job_opts)
+    MediaCollectionIndexingWorker.kickoff_with_task(source, job_args, job_opts ++ [schedule_in: job_offset_seconds])
+  end
+
+  @doc """
+  A helper method to delete all indexing-related tasks for a source.
+  Optionally, you can include executing tasks in the deletion process.
+
+  Returns :ok
+  """
+  def delete_indexing_tasks(%Source{} = source, opts \\ []) do
+    include_executing = Keyword.get(opts, :include_executing, false)
+
+    Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: include_executing)
+    Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker", include_executing: include_executing)
   end
 
   @doc """
@@ -56,6 +72,9 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
   Returns [%MediaItem{} | %Ecto.Changeset{}]
   """
   def index_and_enqueue_download_for_media_items(%Source{} = source) do
+    # The media_profile is needed to determine the quality options to _then_ determine a more
+    # accurate predicted filepath
+    source = Repo.preload(source, [:media_profile])
     # See the method definition below for more info on how file watchers work
     # (important reading if you're not familiar with it)
     {:ok, media_attributes} = setup_file_watcher_and_kickoff_indexing(source)
@@ -94,8 +113,13 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
     {:ok, pid} = FileFollowerServer.start_link()
 
     handler = fn filepath -> setup_file_follower_watcher(pid, filepath, source) end
+
+    command_opts =
+      [output: DownloadOptionBuilder.build_output_path_for(source)] ++
+        DownloadOptionBuilder.build_quality_options_for(source)
+
     runner_opts = [file_listener_handler: handler, use_cookies: source.use_cookies]
-    result = MediaCollection.get_media_attributes_for_collection(source.original_url, runner_opts)
+    result = MediaCollection.get_media_attributes_for_collection(source.original_url, command_opts, runner_opts)
 
     FileFollowerServer.stop(pid)
 
@@ -132,4 +156,14 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpers do
         changeset
     end
   end
+
+  # Find the difference between the current time and the last time the source was indexed
+  defp calculate_job_offset_seconds(%Source{last_indexed_at: nil}), do: 0
+
+  defp calculate_job_offset_seconds(source) do
+    offset_seconds = DateTime.diff(DateTime.utc_now(), source.last_indexed_at, :second)
+    index_frequency_seconds = source.index_frequency_minutes * 60
+
+    max(0, index_frequency_seconds - offset_seconds)
+  end
 end

lib/pinchflat/sources/source.ex

@@ -15,6 +15,7 @@ defmodule Pinchflat.Sources.Source do
   alias Pinchflat.Metadata.SourceMetadata
 
   @allowed_fields ~w(
+    enabled
     collection_name
     collection_id
     collection_type
@@ -64,6 +65,7 @@ defmodule Pinchflat.Sources.Source do
                                 )a
 
   schema "sources" do
+    field :enabled, :boolean, default: true
     # This is _not_ used as the primary key or internally in the database
     # relations. This is only used to prevent an enumeration attack on the streaming
     # and RSS feed endpoints since those _must_ be public (ie: no basic auth)

lib/pinchflat/sources/sources.ex

@@ -15,8 +15,8 @@ defmodule Pinchflat.Sources do
   alias Pinchflat.Metadata.SourceMetadata
   alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadingHelpers
-  alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.SlowIndexing.SlowIndexingHelpers
+  alias Pinchflat.FastIndexing.FastIndexingHelpers
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
 
   @doc """
@@ -255,19 +255,40 @@ defmodule Pinchflat.Sources do
     end
   end
 
-  # If the source is NOT new (ie: updated) and the download_media flag has changed,
+  # If the source is new (ie: not persisted), do nothing
+  defp maybe_handle_media_tasks(%{data: %{__meta__: %{state: state}}}, _source) when state != :loaded do
+    :ok
+  end
+
+  # If the source is NOT new (ie: updated),
   # enqueue or dequeue media download tasks as necessary.
   defp maybe_handle_media_tasks(changeset, source) do
-    case {changeset.data, changeset.changes} do
-      {%{__meta__: %{state: :loaded}}, %{download_media: true}} ->
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
+
+    # We need both current_changes and applied_changes to determine
+    # the course of action to take. For example, we only care if a source is supposed
+    # to be `enabled` or not - we don't care if that information comes from the
+    # current changes or if that's how it already was in the database.
+    # Rephrased, we're essentially using it in place of `get_field/2`
+    case {current_changes, applied_changes} do
+      {%{download_media: true}, %{enabled: true}} ->
         DownloadingHelpers.enqueue_pending_download_tasks(source)
 
-      {%{__meta__: %{state: :loaded}}, %{download_media: false}} ->
+      {%{enabled: true}, %{download_media: true}} ->
+        DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      {%{download_media: false}, _} ->
+        DownloadingHelpers.dequeue_pending_download_tasks(source)
+
+      {%{enabled: false}, _} ->
         DownloadingHelpers.dequeue_pending_download_tasks(source)
 
       _ ->
-        :ok
+        nil
     end
+
+    :ok
   end
 
   defp maybe_run_indexing_task(changeset, source) do
@@ -301,13 +322,22 @@ defmodule Pinchflat.Sources do
   end
 
   defp maybe_update_slow_indexing_task(changeset, source) do
-    case changeset.changes do
-      %{index_frequency_minutes: mins} when mins > 0 ->
+    # See comment in `maybe_handle_media_tasks` as to why we need these
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
+
+    case {current_changes, applied_changes} do
+      {%{index_frequency_minutes: mins}, %{enabled: true}} when mins > 0 ->
         SlowIndexingHelpers.kickoff_indexing_task(source)
 
-      %{index_frequency_minutes: _} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
-        Tasks.delete_pending_tasks_for(source, "MediaCollectionIndexingWorker")
+      {%{enabled: true}, %{index_frequency_minutes: mins}} when mins > 0 ->
+        SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{index_frequency_minutes: _}, _} ->
+        SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
+
+      {%{enabled: false}, _} ->
+        SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
 
       _ ->
         :ok
@@ -315,13 +345,25 @@ defmodule Pinchflat.Sources do
   end
 
   defp maybe_update_fast_indexing_task(changeset, source) do
-    case changeset.changes do
-      %{fast_index: true} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
-        FastIndexingWorker.kickoff_with_task(source)
+    # See comment in `maybe_handle_media_tasks` as to why we need these
+    current_changes = changeset.changes
+    applied_changes = Ecto.Changeset.apply_changes(changeset)
 
-      %{fast_index: false} ->
-        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker")
+    # This technically could be simplified since `maybe_update_slow_indexing_task`
+    # has some overlap re: deleting pending tasks, but I'm keeping it separate
+    # for clarity and explicitness.
+    case {current_changes, applied_changes} do
+      {%{fast_index: true}, %{enabled: true}} ->
+        FastIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{enabled: true}, %{fast_index: true}} ->
+        FastIndexingHelpers.kickoff_indexing_task(source)
+
+      {%{fast_index: false}, _} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
+
+      {%{enabled: false}, _} ->
+        Tasks.delete_pending_tasks_for(source, "FastIndexingWorker", include_executing: true)
 
       _ ->
         :ok

lib/pinchflat/yt_dlp/media.ex

@@ -11,7 +11,8 @@ defmodule Pinchflat.YtDlp.Media do
     :livestream,
     :short_form_content,
     :uploaded_at,
-    :duration_seconds
+    :duration_seconds,
+    :predicted_media_filepath
   ]
 
   defstruct [
@@ -23,7 +24,8 @@ defmodule Pinchflat.YtDlp.Media do
     :short_form_content,
     :uploaded_at,
     :duration_seconds,
-    :playlist_index
+    :playlist_index,
+    :predicted_media_filepath
   ]
 
   alias __MODULE__
@@ -47,6 +49,24 @@ defmodule Pinchflat.YtDlp.Media do
     end
   end
 
+  @doc """
+  Determines if the media at the given URL is ready to be downloaded.
+  Common examples of non-downloadable media are upcoming or in-progress live streams.
+
+  Returns {:ok, :downloadable | :ignorable} | {:error, any}
+  """
+  def get_downloadable_status(url) do
+    case backend_runner().run(url, [:simulate, :skip_download], "%(.{live_status})j") do
+      {:ok, output} ->
+        output
+        |> Phoenix.json_library().decode!()
+        |> parse_downloadable_status()
+
+      err ->
+        err
+    end
+  end
+
   @doc """
   Downloads a thumbnail for a single piece of media. Usually used for
   downloading thumbnails for internal use
@@ -63,15 +83,16 @@ defmodule Pinchflat.YtDlp.Media do
 
   @doc """
   Returns a map representing the media at the given URL.
+  Optionally takes a list of additional command options to pass to yt-dlp
+  or configuration-related options to pass to the runner.
 
   Returns {:ok, %Media{}} | {:error, any, ...}.
   """
-  def get_media_attributes(url, addl_opts \\ []) do
-    runner = Application.get_env(:pinchflat, :yt_dlp_runner)
-    command_opts = [:simulate, :skip_download]
+  def get_media_attributes(url, command_opts \\ [], addl_opts \\ []) do
+    all_command_opts = [:simulate, :skip_download] ++ command_opts
     output_template = indexing_output_template()
 
-    case runner.run(url, command_opts, output_template, addl_opts) do
+    case backend_runner().run(url, all_command_opts, output_template, addl_opts) do
       {:ok, output} ->
         output
         |> Phoenix.json_library().decode!()
@@ -91,7 +112,7 @@ defmodule Pinchflat.YtDlp.Media do
         if something is a short via the URL again
   """
   def indexing_output_template do
-    "%(.{id,title,live_status,original_url,description,aspect_ratio,duration,upload_date,timestamp,playlist_index})j"
+    "%(.{id,title,live_status,original_url,description,aspect_ratio,duration,upload_date,timestamp,playlist_index,filename})j"
   end
 
   @doc """
@@ -110,7 +131,8 @@ defmodule Pinchflat.YtDlp.Media do
       duration_seconds: response["duration"] && round(response["duration"]),
       short_form_content: response["original_url"] && short_form_content?(response),
       uploaded_at: response["upload_date"] && parse_uploaded_at(response),
-      playlist_index: response["playlist_index"] || 0
+      playlist_index: response["playlist_index"] || 0,
+      predicted_media_filepath: response["filename"]
     }
   end
 
@@ -142,6 +164,16 @@ defmodule Pinchflat.YtDlp.Media do
   defp parse_uploaded_at(%{"upload_date" => nil}), do: nil
   defp parse_uploaded_at(response), do: MetadataFileHelpers.parse_upload_date(response["upload_date"])
 
+  defp parse_downloadable_status(response) do
+    case response["live_status"] do
+      status when status in ["is_live", "is_upcoming", "post_live"] -> {:ok, :ignorable}
+      status when status in ["was_live", "not_live"] -> {:ok, :downloadable}
+      # This preserves my tenuous support for non-youtube sources.
+      nil -> {:ok, :downloadable}
+      _ -> {:error, "Unknown live status: #{response["live_status"]}"}
+    end
+  end
+
   defp backend_runner do
     # This approach lets us mock the command for testing
     Application.get_env(:pinchflat, :yt_dlp_runner)

lib/pinchflat/yt_dlp/media_collection.ex

@@ -11,20 +11,23 @@ defmodule Pinchflat.YtDlp.MediaCollection do
 
   @doc """
   Returns a list of maps representing the media in the collection.
+  Optionally takes a list of additional command options to pass to yt-dlp
+  or configuration-related options to pass to the runner.
 
-  Options:
+  Runner Options:
     - :file_listener_handler - a function that will be called with the path to the
       file that will be written to when yt-dlp is done. This is useful for
       setting up a file watcher to know when the file is ready to be read.
+    - :use_cookies - whether or not to use user-provided cookies when fetching the media details
 
   Returns {:ok, [map()]} | {:error, any, ...}.
   """
-  def get_media_attributes_for_collection(url, addl_opts \\ []) do
+  def get_media_attributes_for_collection(url, command_opts \\ [], addl_opts \\ []) do
     runner = Application.get_env(:pinchflat, :yt_dlp_runner)
     # `ignore_no_formats_error` is necessary because yt-dlp will error out if
     # the first video has not released yet (ie: is a premier). We don't care about
     # available formats since we're just getting the media details
-    command_opts = [:simulate, :skip_download, :ignore_no_formats_error, :no_warnings]
+    all_command_opts = [:simulate, :skip_download, :ignore_no_formats_error, :no_warnings] ++ command_opts
     use_cookies = Keyword.get(addl_opts, :use_cookies, false)
     output_template = YtDlpMedia.indexing_output_template()
     output_filepath = FilesystemUtils.generate_metadata_tmpfile(:json)
@@ -35,7 +38,7 @@ defmodule Pinchflat.YtDlp.MediaCollection do
       file_listener_handler.(output_filepath)
     end
 
-    case runner.run(url, command_opts, output_template, runner_opts) do
+    case runner.run(url, all_command_opts, output_template, runner_opts) do
       {:ok, output} ->
         parsed_lines =
           output

lib/pinchflat_web/components/core_components.ex

@@ -340,14 +340,15 @@ defmodule PinchflatWeb.CoreComponents do
       end)
 
     ~H"""
-    <div x-data={"{ enabled: #{@checked}}"}>
-      <.label for={@id}>
+    <div x-data={"{ enabled: #{@checked} }"} class="" phx-update="ignore" id={"#{@id}-wrapper"}>
+      <.label :if={@label} for={@id}>
         <%= @label %>
         <span :if={@label_suffix} class="text-xs text-bodydark"><%= @label_suffix %></span>
       </.label>
-      <div class="relative">
+      <div class="relative flex flex-col">
         <input type="hidden" id={@id} name={@name} x-bind:value="enabled" {@rest} />
-        <div class="inline-block cursor-pointer" @click="enabled = !enabled">
+        <%!-- This triggers a `change` event on the hidden input when the toggle is clicked --%>
+        <div class="inline-block cursor-pointer" @click={"enabled = !enabled; dispatchFor('#{@id}', 'change')"}>
           <div x-bind:class="enabled && '!bg-primary'" class="block h-8 w-14 rounded-full bg-black"></div>
           <div
             x-bind:class="enabled && '!right-1 !translate-x-full'"

lib/pinchflat_web/components/layouts/partials/upgrade_button_live.ex

@@ -3,7 +3,7 @@ defmodule Pinchflat.UpgradeButtonLive do
 
   def render(assigns) do
     ~H"""
-    <form id="upgradeForm" phx-change="check_matching_text" phx-hook="supressEnterSubmission">
+    <form id="upgradeForm" phx-change="check_matching_text" phx-hook="supress-enter-submission">
       <.input type="text" name="unlock-pro-textbox" value="" />
     </form>
 

lib/pinchflat_web/controllers/media_items/media_item_html/media_preview.heex

@@ -1,13 +1,13 @@
 <%= if media_type(@media_item) == :video do %>
   <video controls class="max-h-128 w-full">
-    <source src={~p"/media/#{@media_item.uuid}/stream"} type="video/mp4" />
+    <source src={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"} type="video/mp4" />
     Your browser does not support the video element.
   </video>
 <% end %>
 
 <%= if media_type(@media_item) == :audio do %>
   <audio controls class="w-full">
-    <source src={~p"/media/#{@media_item.uuid}/stream"} type="audio/mpeg" />
+    <source src={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"} type="audio/mpeg" />
     Your browser does not support the audio element.
   </audio>
 <% end %>

lib/pinchflat_web/controllers/media_items/media_item_html/show.html.heex

@@ -39,7 +39,10 @@
                     <span class="mx-2">or</span>
                   </span>
                   <span>
-                    <.subtle_link href={~p"/media/#{@media_item.uuid}/stream"} target="_blank">
+                    <.subtle_link
+                      href={~p"/media/#{@media_item.uuid}/stream?v=#{DateTime.to_unix(@media_item.updated_at)}"}
+                      target="_blank"
+                    >
                       Open Local Stream
                     </.subtle_link>
                   </span>

lib/pinchflat_web/controllers/media_profiles/media_profile_controller.ex

@@ -1,26 +1,51 @@
 defmodule PinchflatWeb.MediaProfiles.MediaProfileController do
   use PinchflatWeb, :controller
   use Pinchflat.Sources.SourcesQuery
+  use Pinchflat.Profiles.ProfilesQuery
 
   alias Pinchflat.Repo
   alias Pinchflat.Profiles
+  alias Pinchflat.Sources.Source
   alias Pinchflat.Profiles.MediaProfile
   alias Pinchflat.Profiles.MediaProfileDeletionWorker
 
   def index(conn, _params) do
-    media_profiles =
-      MediaProfile
-      |> where([mp], is_nil(mp.marked_for_deletion_at))
-      |> order_by(asc: :name)
-      |> Repo.all()
+    media_profiles_query =
+      from mp in MediaProfile,
+        as: :media_profile,
+        where: is_nil(mp.marked_for_deletion_at),
+        order_by: [asc: mp.name],
+        select: map(mp, ^MediaProfile.__schema__(:fields)),
+        select_merge: %{
+          source_count:
+            subquery(
+              from s in Source,
+                where: s.media_profile_id == parent_as(:media_profile).id,
+                select: count(s.id)
+            )
+        }
 
-    render(conn, :index, media_profiles: media_profiles)
+    render(conn, :index, media_profiles: Repo.all(media_profiles_query))
   end
 
-  def new(conn, _params) do
-    changeset = Profiles.change_media_profile(%MediaProfile{})
+  def new(conn, params) do
+    # Preload an existing media profile for faster creation
+    cs_struct =
+      case to_string(params["template_id"]) do
+        "" -> %MediaProfile{}
+        template_id -> Repo.get(MediaProfile, template_id) || %MediaProfile{}
+      end
 
-    render(conn, :new, changeset: changeset, layout: get_onboarding_layout())
+    render(conn, :new,
+      layout: get_onboarding_layout(),
+      changeset:
+        Profiles.change_media_profile(%MediaProfile{
+          cs_struct
+          | id: nil,
+            name: nil,
+            marked_for_deletion_at: nil
+        })
+    )
   end
 
   def create(conn, %{"media_profile" => media_profile_params}) do

lib/pinchflat_web/controllers/media_profiles/media_profile_html.ex

@@ -10,6 +10,7 @@ defmodule PinchflatWeb.MediaProfiles.MediaProfileHTML do
   """
   attr :changeset, Ecto.Changeset, required: true
   attr :action, :string, required: true
+  attr :method, :string, required: true
 
   def media_profile_form(assigns)
 

lib/pinchflat_web/controllers/media_profiles/media_profile_html/actions_dropdown.html.heex

@@ -11,6 +11,11 @@
       <span x-show="copied" x-transition.duration.150ms><.icon name="hero-check" class="ml-2 h-4 w-4" /></span>
     </span>
   </:option>
+  <:option>
+    <.link href={~p"/media_profiles/new?template_id=#{@media_profile}"} method="get">
+      Use as Template
+    </.link>
+  </:option>
   <:option>
     <div class="h-px w-full bg-bodydark2"></div>
   </:option>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/edit.html.heex

@@ -10,7 +10,7 @@
 <div class="rounded-sm border border-stroke bg-white px-5 pb-2.5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5 xl:pb-1">
   <div class="max-w-full">
     <div class="flex flex-col gap-10">
-      <.media_profile_form changeset={@changeset} action={~p"/media_profiles/#{@media_profile}"} />
+      <.media_profile_form changeset={@changeset} action={~p"/media_profiles/#{@media_profile}"} method="patch" />
     </div>
   </div>
 </div>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/index.html.heex

@@ -10,7 +10,6 @@
     </.link>
   </nav>
 </div>
-
 <div class="rounded-sm border border-stroke bg-white shadow-default dark:border-strokedark dark:bg-boxdark">
   <div class="max-w-full overflow-x-auto">
     <div class="flex flex-col gap-10 min-w-max">
@@ -23,6 +22,11 @@
         <:col :let={media_profile} label="Preferred Resolution">
           <%= media_profile.preferred_resolution %>
         </:col>
+        <:col :let={media_profile} label="Sources">
+          <.subtle_link href={~p"/media_profiles/#{media_profile.id}/#tab-sources"}>
+            <.localized_number number={media_profile.source_count} />
+          </.subtle_link>
+        </:col>
         <:col :let={media_profile} label="" class="flex justify-end">
           <.icon_link href={~p"/media_profiles/#{media_profile.id}/edit"} icon="hero-pencil-square" class="mr-4" />
         </:col>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/media_profile_form.html.heex

@@ -2,6 +2,7 @@
   :let={f}
   for={@changeset}
   action={@action}
+  method={@method}
   x-data="{ advancedMode: !!JSON.parse(localStorage.getItem('advancedMode')) }"
   x-init="$watch('advancedMode', value => localStorage.setItem('advancedMode', JSON.stringify(value)))"
 >
@@ -124,6 +125,16 @@
       />
     </section>
 
+    <section x-show="advancedMode">
+      <.input
+        field={f[:audio_track]}
+        placeholder="de"
+        type="text"
+        label="Audio Track Language"
+        help="Only works if there are multiple audio tracks. Use either a language code, 'original' for the original audio track, or 'default' for YouTube's preference. Or just leave it blank"
+      />
+    </section>
+
     <h3 class="mt-10 text-2xl text-black dark:text-white">
       Thumbnail Options
     </h3>

lib/pinchflat_web/controllers/media_profiles/media_profile_html/new.html.heex

@@ -8,7 +8,7 @@
 <div class="rounded-sm border border-stroke bg-white px-5 pb-2.5 pt-6 shadow-default dark:border-strokedark dark:bg-boxdark sm:px-7.5 xl:pb-1">
   <div class="max-w-full">
     <div class="flex flex-col gap-10">
-      <.media_profile_form changeset={@changeset} action={~p"/media_profiles"} />
+      <.media_profile_form changeset={@changeset} action={~p"/media_profiles"} method="post" />
     </div>
   </div>
 </div>

lib/pinchflat_web/controllers/sources/source_controller.ex

@@ -1,12 +1,11 @@
 defmodule PinchflatWeb.Sources.SourceController do
   use PinchflatWeb, :controller
-  use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
 
   alias Pinchflat.Repo
   alias Pinchflat.Tasks
   alias Pinchflat.Sources
   alias Pinchflat.Sources.Source
-  alias Pinchflat.Media.MediaItem
   alias Pinchflat.Profiles.MediaProfile
   alias Pinchflat.Media.FileSyncingWorker
   alias Pinchflat.Sources.SourceDeletionWorker
@@ -15,33 +14,7 @@ defmodule PinchflatWeb.Sources.SourceController do
   alias Pinchflat.Metadata.SourceMetadataStorageWorker
 
   def index(conn, _params) do
-    source_query =
-      from s in Source,
-        as: :source,
-        inner_join: mp in assoc(s, :media_profile),
-        where: is_nil(s.marked_for_deletion_at) and is_nil(mp.marked_for_deletion_at),
-        preload: [media_profile: mp],
-        order_by: [asc: s.custom_name],
-        select: map(s, ^Source.__schema__(:fields)),
-        select_merge: %{
-          downloaded_count:
-            subquery(
-              from m in MediaItem,
-                where: m.source_id == parent_as(:source).id,
-                where: ^MediaQuery.downloaded(),
-                select: count(m.id)
-            ),
-          pending_count:
-            subquery(
-              from m in MediaItem,
-                join: s in assoc(m, :source),
-                where: m.source_id == parent_as(:source).id,
-                where: ^MediaQuery.pending(),
-                select: count(m.id)
-            )
-        }
-
-    render(conn, :index, sources: Repo.all(source_query))
+    render(conn, :index)
   end
 
   def new(conn, params) do
@@ -67,7 +40,8 @@ defmodule PinchflatWeb.Sources.SourceController do
             collection_name: nil,
             collection_id: nil,
             collection_type: nil,
-            original_url: nil
+            original_url: nil,
+            marked_for_deletion_at: nil
         })
     )
   end

lib/pinchflat_web/controllers/sources/source_html/index.html.heex

@@ -12,32 +12,7 @@
 <div class="rounded-sm border border-stroke bg-white shadow-default dark:border-strokedark dark:bg-boxdark">
   <div class="max-w-full overflow-x-auto">
     <div class="flex flex-col gap-10 min-w-max">
-      <.table rows={@sources} table_class="text-black dark:text-white">
-        <:col :let={source} label="Name">
-          <.subtle_link href={~p"/sources/#{source.id}"}>
-            <%= StringUtils.truncate(source.custom_name || source.collection_name, 35) %>
-          </.subtle_link>
-        </:col>
-        <:col :let={source} label="Type"><%= source.collection_type %></:col>
-        <:col :let={source} label="Pending"><.localized_number number={source.pending_count} /></:col>
-        <:col :let={source} label="Downloaded"><.localized_number number={source.downloaded_count} /></:col>
-        <:col :let={source} label="Retention">
-          <%= if source.retention_period_days && source.retention_period_days > 0 do %>
-            <.localized_number number={source.retention_period_days} />
-            <.pluralize count={source.retention_period_days} word="day" />
-          <% else %>
-            <span class="text-lg">∞</span>
-          <% end %>
-        </:col>
-        <:col :let={source} label="Media Profile">
-          <.subtle_link href={~p"/media_profiles/#{source.media_profile_id}"}>
-            <%= source.media_profile.name %>
-          </.subtle_link>
-        </:col>
-        <:col :let={source} label="" class="flex place-content-evenly">
-          <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
-        </:col>
-      </.table>
+      <%= live_render(@conn, PinchflatWeb.Sources.IndexTableLive) %>
     </div>
   </div>
 </div>

lib/pinchflat_web/controllers/sources/source_html/index_table_live.ex

@@ -0,0 +1,103 @@
+defmodule PinchflatWeb.Sources.IndexTableLive do
+  use PinchflatWeb, :live_view
+  use Pinchflat.Media.MediaQuery
+  use Pinchflat.Sources.SourcesQuery
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Sources
+  alias Pinchflat.Sources.Source
+  alias Pinchflat.Media.MediaItem
+
+  def render(assigns) do
+    ~H"""
+    <.table rows={@sources} table_class="text-white">
+      <:col :let={source} label="Name">
+        <.subtle_link href={~p"/sources/#{source.id}"}>
+          <%= StringUtils.truncate(source.custom_name || source.collection_name, 35) %>
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Pending">
+        <.subtle_link href={~p"/sources/#{source.id}/#tab-pending"}>
+          <.localized_number number={source.pending_count} />
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Downloaded">
+        <.subtle_link href={~p"/sources/#{source.id}/#tab-downloaded"}>
+          <.localized_number number={source.downloaded_count} />
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Retention">
+        <%= if source.retention_period_days && source.retention_period_days > 0 do %>
+          <.localized_number number={source.retention_period_days} />
+          <.pluralize count={source.retention_period_days} word="day" />
+        <% else %>
+          <span class="text-lg">∞</span>
+        <% end %>
+      </:col>
+      <:col :let={source} label="Media Profile">
+        <.subtle_link href={~p"/media_profiles/#{source.media_profile_id}"}>
+          <%= source.media_profile.name %>
+        </.subtle_link>
+      </:col>
+      <:col :let={source} label="Enabled?">
+        <.input
+          name={"source[#{source.id}][enabled]"}
+          value={source.enabled}
+          id={"source_#{source.id}_enabled"}
+          phx-hook="formless-input"
+          data-subscribe="change"
+          data-event-name="toggle_enabled"
+          data-identifier={source.id}
+          type="toggle"
+        />
+      </:col>
+      <:col :let={source} label="" class="flex place-content-evenly">
+        <.icon_link href={~p"/sources/#{source.id}/edit"} icon="hero-pencil-square" class="mx-1" />
+      </:col>
+    </.table>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, %{sources: get_sources()})}
+  end
+
+  def handle_event("formless-input", %{"event" => "toggle_enabled"} = params, socket) do
+    source = Sources.get_source!(params["id"])
+    should_enable = params["value"] == "true"
+
+    {:ok, _} = Sources.update_source(source, %{enabled: should_enable})
+
+    {:noreply, assign(socket, %{sources: get_sources()})}
+  end
+
+  defp get_sources do
+    query =
+      from s in Source,
+        as: :source,
+        inner_join: mp in assoc(s, :media_profile),
+        where: is_nil(s.marked_for_deletion_at) and is_nil(mp.marked_for_deletion_at),
+        preload: [media_profile: mp],
+        order_by: [asc: s.custom_name],
+        select: map(s, ^Source.__schema__(:fields)),
+        select_merge: %{
+          downloaded_count:
+            subquery(
+              from m in MediaItem,
+                where: m.source_id == parent_as(:source).id,
+                where: ^MediaQuery.downloaded(),
+                select: count(m.id)
+            ),
+          pending_count:
+            subquery(
+              from m in MediaItem,
+                join: s in assoc(m, :source),
+                where: m.source_id == parent_as(:source).id,
+                where: ^MediaQuery.pending(),
+                select: count(m.id)
+            )
+        }
+
+    Repo.all(query)
+  end
+end

lib/pinchflat_web/controllers/sources/source_html/media_item_table_live.ex

@@ -1,4 +1,4 @@
-defmodule Pinchflat.Sources.MediaItemTableLive do
+defmodule PinchflatWeb.Sources.MediaItemTableLive do
   use PinchflatWeb, :live_view
   use Pinchflat.Media.MediaQuery
 

lib/pinchflat_web/controllers/sources/source_html/show.html.heex

@@ -39,21 +39,21 @@
       <:tab title="Pending" id="pending">
         <%= live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "pending"}
         ) %>
       </:tab>
       <:tab title="Downloaded" id="downloaded">
         <%= live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "downloaded"}
         ) %>
       </:tab>
       <:tab title="Other" id="other">
         <%= live_render(
           @conn,
-          Pinchflat.Sources.MediaItemTableLive,
+          PinchflatWeb.Sources.MediaItemTableLive,
           session: %{"source_id" => @source.id, "media_state" => "other"}
         ) %>
       </:tab>

mix.exs

@@ -4,7 +4,7 @@ defmodule Pinchflat.MixProject do
   def project do
     [
       app: :pinchflat,
-      version: "2024.10.30",
+      version: "2024.11.27",
       elixir: "~> 1.17",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,

priv/repo/migrations/20241107201850_add_predicted_media_filepath_to_media_items.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddPredictedMediaFilepathToMediaItems do
+  use Ecto.Migration
+
+  def change do
+    alter table(:media_items) do
+      add :predicted_media_filepath, :string
+    end
+  end
+end

priv/repo/migrations/20241120204407_add_enabled_to_sources.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddEnabledToSources do
+  use Ecto.Migration
+
+  def change do
+    alter table(:sources) do
+      add :enabled, :boolean, default: true, null: false
+    end
+  end
+end

priv/repo/migrations/20241127172054_add_audio_lang_to_media_profiles.exs

@@ -0,0 +1,9 @@
+defmodule Pinchflat.Repo.Migrations.AddAudioLangToMediaProfiles do
+  use Ecto.Migration
+
+  def change do
+    alter table(:media_profiles) do
+      add :audio_track, :string
+    end
+  end
+end

test/pinchflat/boot/pre_job_startup_tasks_test.exs

@@ -9,6 +9,7 @@ defmodule Pinchflat.Boot.PreJobStartupTasksTest do
   setup do
     stub(YtDlpRunnerMock, :version, fn -> {:ok, "1"} end)
     stub(AppriseRunnerMock, :version, fn -> {:ok, "2"} end)
+    stub(UserScriptRunnerMock, :run, fn _event_type, _data -> {:ok, "3", 0} end)
 
     :ok
   end
@@ -112,4 +113,16 @@ defmodule Pinchflat.Boot.PreJobStartupTasksTest do
       assert Settings.get!(:apprise_version)
     end
   end
+
+  describe "run_app_init_script" do
+    test "calls the app_init user script runner" do
+      expect(UserScriptRunnerMock, :run, fn :app_init, data ->
+        assert data == %{}
+
+        {:ok, "", 0}
+      end)
+
+      PreJobStartupTasks.init(%{})
+    end
+  end
 end

test/pinchflat/downloading/download_option_builder_test.exs

@@ -6,7 +6,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
 
   alias Pinchflat.Sources
   alias Pinchflat.Profiles
-  alias Pinchflat.Settings
   alias Pinchflat.Utils.FilesystemUtils
   alias Pinchflat.Downloading.DownloadOptionBuilder
 
@@ -253,21 +252,14 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
   end
 
   describe "build/1 when testing media quality and format options" do
-    test "includes quality options" do
-      resolutions = ["360", "480", "720", "1080", "2160", "4320"]
+    # There are more tests inside QualityOptionBuilderTest
+    # This is essenitally just testing that we implement that module correctly
 
-      Enum.each(resolutions, fn resolution ->
-        resolution_atom = String.to_existing_atom(resolution <> "p")
+    test "includes video options for video profiles", %{media_item: media_item} do
+      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
 
-        media_profile = media_profile_fixture(%{preferred_resolution: resolution_atom})
-        source = source_fixture(%{media_profile_id: media_profile.id})
-        media_item = Repo.preload(media_item_fixture(source_id: source.id), source: :media_profile)
-
-        assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-        assert {:format_sort, "res:#{resolution},+codec:avc:m4a"} in res
-        assert {:remux_video, "mp4"} in res
-      end)
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in res
+      assert {:remux_video, "mp4"} in res
     end
 
     test "includes quality options for audio only", %{media_item: media_item} do
@@ -280,33 +272,6 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
 
       refute {:remux_video, "mp4"} in res
     end
-
-    test "includes custom quality options if specified", %{media_item: media_item} do
-      Settings.set(video_codec_preference: "av01")
-      Settings.set(audio_codec_preference: "aac")
-
-      media_item = update_media_profile_attribute(media_item, %{preferred_resolution: :"1080p"})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:format_sort, "res:1080,+codec:av01:aac"} in res
-    end
-
-    test "includes custom remux target for videos if specified", %{media_item: media_item} do
-      media_item = update_media_profile_attribute(media_item, %{media_container: "mkv"})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:remux_video, "mkv"} in res
-    end
-
-    test "includes custom format target for audio if specified", %{media_item: media_item} do
-      media_item = update_media_profile_attribute(media_item, %{media_container: "flac", preferred_resolution: :audio})
-
-      assert {:ok, res} = DownloadOptionBuilder.build(media_item)
-
-      assert {:audio_format, "flac"} in res
-    end
   end
 
   describe "build/1 when testing sponsorblock options" do
@@ -461,6 +426,22 @@ defmodule Pinchflat.Downloading.DownloadOptionBuilderTest do
     end
   end
 
+  describe "build_quality_options_for/1" do
+    test "builds quality options for a media item", %{media_item: media_item} do
+      options = DownloadOptionBuilder.build_quality_options_for(media_item)
+
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in options
+      assert {:remux_video, "mp4"} in options
+    end
+
+    test "builds quality options for a source", %{media_item: media_item} do
+      options = DownloadOptionBuilder.build_quality_options_for(media_item.source)
+
+      assert {:format_sort, "res:1080,+codec:avc:m4a"} in options
+      assert {:remux_video, "mp4"} in options
+    end
+  end
+
   defp update_media_profile_attribute(media_item_with_preloads, attrs) do
     media_item_with_preloads.source.media_profile
     |> Profiles.change_media_profile(attrs)

test/pinchflat/downloading/media_download_worker_test.exs

@@ -9,6 +9,7 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
   alias Pinchflat.Downloading.MediaDownloadWorker
 
   setup do
+    stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot -> {:ok, "{}"} end)
     stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
     stub(UserScriptRunnerMock, :run, fn _event_type, _data -> {:ok, "", 0} end)
     stub(HTTPClientMock, :get, fn _url, _headers, _opts -> {:ok, ""} end)
@@ -186,6 +187,20 @@ defmodule Pinchflat.Downloading.MediaDownloadWorkerTest do
     end
   end
 
+  describe "perform/1 when testing non-downloadable media" do
+    test "does not retry the job if the media is currently not downloadable", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      Oban.Testing.with_testing_mode(:inline, fn ->
+        {:ok, job} = Oban.insert(MediaDownloadWorker.new(%{id: media_item.id}))
+
+        assert job.state == "completed"
+      end)
+    end
+  end
+
   describe "perform/1 when testing forced downloads" do
     test "ignores 'prevent_download' if forced", %{media_item: media_item} do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl -> :ok end)

test/pinchflat/downloading/media_downloader_test.exs

@@ -16,6 +16,7 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
       )
 
     stub(HTTPClientMock, :get, fn _url, _headers, _opts -> {:ok, ""} end)
+    stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot -> {:ok, "{}"} end)
     stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_args -> {:ok, ""} end)
 
     {:ok, %{media_item: media_item}}
@@ -49,6 +50,14 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
       assert updated_media_item.metadata.thumbnail_filepath =~ "media_items/#{media_item.id}/thumbnail.jpg"
     end
 
+    test "errors for non-downloadable media are passed through", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      assert {:error, :unsuitable_for_download} = MediaDownloader.download_for_media_item(media_item)
+    end
+
     test "non-recoverable errors are passed through", %{media_item: media_item} do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl ->
         {:error, :some_error, 1}
@@ -67,6 +76,36 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
     end
   end
 
+  describe "download_for_media_item/3 when testing non-downloadable media" do
+    test "calls the download runner if the media is currently downloadable", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "was_live"})}
+      end)
+
+      expect(YtDlpRunnerMock, :run, 2, fn _url, _opts, _ot, _addl ->
+        {:ok, render_metadata(:media_metadata)}
+      end)
+
+      assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)
+    end
+
+    test "does not call the download runner if the media is not downloadable", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      expect(YtDlpRunnerMock, :run, 0, fn _url, _opts, _ot, _addl -> {:ok, ""} end)
+
+      assert {:error, :unsuitable_for_download} = MediaDownloader.download_for_media_item(media_item)
+    end
+
+    test "returns unexpected errors from the download status determination method", %{media_item: media_item} do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot -> {:error, :what_tha} end)
+
+      assert {:error, "Unknown error: {:error, :what_tha}"} = MediaDownloader.download_for_media_item(media_item)
+    end
+  end
+
   describe "download_for_media_item/3 when testing override options" do
     test "includes override opts if specified", %{media_item: media_item} do
       expect(YtDlpRunnerMock, :run, 1, fn _url, opts, _ot, _addl ->

test/pinchflat/downloading/quality_option_builder_test.exs

@@ -0,0 +1,109 @@
+defmodule Pinchflat.Downloading.QualityOptionBuilderTest do
+  use Pinchflat.DataCase
+  import Pinchflat.ProfilesFixtures
+
+  alias Pinchflat.Profiles
+  alias Pinchflat.Settings
+  alias Pinchflat.Downloading.QualityOptionBuilder
+
+  describe "build/1" do
+    test "includes format options if audio_track is set to original" do
+      media_profile = media_profile_fixture(%{audio_track: "original"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[format_note*=original]/bestvideo*+bestaudio/best"} in res
+    end
+
+    test "includes format options if audio_track is set to default" do
+      media_profile = media_profile_fixture(%{audio_track: "default"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[format_note*='(default)']/bestvideo*+bestaudio/best"} in res
+    end
+
+    test "includes format options if audio_track is set to a language code" do
+      media_profile = media_profile_fixture(%{audio_track: "en"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo+bestaudio[language^=en]/bestvideo*+bestaudio/best"} in res
+    end
+  end
+
+  describe "build/1 when testing audio profiles" do
+    setup do
+      {:ok, media_profile: media_profile_fixture(%{preferred_resolution: :audio})}
+    end
+
+    test "includes quality options for audio only", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert :extract_audio in res
+      assert {:format_sort, "+acodec:m4a"} in res
+
+      refute {:remux_video, "mp4"} in res
+    end
+
+    test "includes custom format target for audio if specified", %{media_profile: media_profile} do
+      {:ok, media_profile} =
+        Profiles.update_media_profile(media_profile, %{media_container: "flac", preferred_resolution: :audio})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:audio_format, "flac"} in res
+    end
+
+    test "includes custom format options", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestaudio/best"} in res
+    end
+  end
+
+  describe "build/1 when testing non-audio profiles" do
+    setup do
+      {:ok, media_profile: media_profile_fixture(%{preferred_resolution: :"480p"})}
+    end
+
+    test "includes quality options" do
+      resolutions = ["360", "480", "720", "1080", "2160", "4320"]
+
+      Enum.each(resolutions, fn resolution ->
+        resolution_atom = String.to_existing_atom(resolution <> "p")
+        media_profile = media_profile_fixture(%{preferred_resolution: resolution_atom})
+
+        assert res = QualityOptionBuilder.build(media_profile)
+
+        assert {:format_sort, "res:#{resolution},+codec:avc:m4a"} in res
+        assert {:remux_video, "mp4"} in res
+      end)
+    end
+
+    test "includes custom quality options if specified", %{media_profile: media_profile} do
+      Settings.set(video_codec_preference: "av01")
+      Settings.set(audio_codec_preference: "aac")
+
+      {:ok, media_profile} = Profiles.update_media_profile(media_profile, %{preferred_resolution: :"1080p"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format_sort, "res:1080,+codec:av01:aac"} in res
+    end
+
+    test "includes custom remux target for videos if specified", %{media_profile: media_profile} do
+      {:ok, media_profile} = Profiles.update_media_profile(media_profile, %{media_container: "mkv"})
+
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:remux_video, "mkv"} in res
+    end
+
+    test "includes custom format options", %{media_profile: media_profile} do
+      assert res = QualityOptionBuilder.build(media_profile)
+
+      assert {:format, "bestvideo*+bestaudio/best"} in res
+    end
+  end
+end

test/pinchflat/fast_indexing/fast_indexing_helpers_test.exs

@@ -1,6 +1,7 @@
 defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
   use Pinchflat.DataCase
 
+  import Pinchflat.TasksFixtures
   import Pinchflat.MediaFixtures
   import Pinchflat.SourcesFixtures
   import Pinchflat.ProfilesFixtures
@@ -8,6 +9,7 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
   alias Pinchflat.Tasks
   alias Pinchflat.Settings
   alias Pinchflat.Media.MediaItem
+  alias Pinchflat.FastIndexing.FastIndexingWorker
   alias Pinchflat.Downloading.MediaDownloadWorker
   alias Pinchflat.FastIndexing.FastIndexingHelpers
 
@@ -19,6 +21,23 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
     {:ok, [source: source_fixture()]}
   end
 
+  describe "kickoff_indexing_task/1" do
+    test "deletes any existing fast indexing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert Repo.reload!(task)
+      assert {:ok, _} = FastIndexingHelpers.kickoff_indexing_task(source)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+
+    test "kicks off a new fast indexing task", %{source: source} do
+      assert {:ok, _} = FastIndexingHelpers.kickoff_indexing_task(source)
+      assert [worker] = all_enqueued(worker: FastIndexingWorker)
+      assert worker.args["id"] == source.id
+    end
+  end
+
   describe "kickoff_download_tasks_from_youtube_rss_feed/1" do
     test "enqueues a new worker for each new media_id in the source's RSS feed", %{source: source} do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
@@ -61,6 +80,18 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
       assert [_] = Tasks.list_tasks_for(media_item, "MediaDownloadWorker")
     end
 
+    test "passes the source's download options to the yt-dlp runner", %{source: source} do
+      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
+
+      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl_opts ->
+        assert {:output, "/tmp/test/media/%(title)S.%(ext)S"} in opts
+        assert {:remux_video, "mp4"} in opts
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      FastIndexingHelpers.kickoff_download_tasks_from_youtube_rss_feed(source)
+    end
+
     test "sets use_cookies if the source uses cookies" do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 

test/pinchflat/slow_indexing/slow_indexing_helpers_test.exs

@@ -23,6 +23,36 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
     end
 
+    test "schedules a job for the future based on when the source was last indexed" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: now_minus(5, :minutes))
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :minute), 25, 1
+    end
+
+    test "schedules a job immediately if the source was indexed far in the past" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: now_minus(60, :minutes))
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :second), 0, 1
+    end
+
+    test "schedules a job immediately if the source has never been indexed" do
+      source = source_fixture(index_frequency_minutes: 30, last_indexed_at: nil)
+
+      assert {:ok, _} = SlowIndexingHelpers.kickoff_indexing_task(source)
+
+      [job] = all_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+
+      assert_in_delta DateTime.diff(job.scheduled_at, DateTime.utc_now(), :second), 0, 1
+    end
+
     test "creates and attaches a task" do
       source = source_fixture(index_frequency_minutes: 1)
 
@@ -92,6 +122,56 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
     end
   end
 
+  describe "delete_indexing_tasks/2" do
+    setup do
+      source = source_fixture()
+
+      {:ok, %{source: source}}
+    end
+
+    test "deletes slow indexing tasks for the source", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      _task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+    end
+
+    test "deletes fast indexing tasks for the source", %{source: source} do
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      _task = task_fixture(source_id: source.id, job_id: job.id)
+
+      assert_enqueued(worker: FastIndexingWorker, args: %{"id" => source.id})
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      refute_enqueued(worker: FastIndexingWorker)
+    end
+
+    test "doesn't normally delete currently executing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      from(Oban.Job, where: [id: ^job.id], update: [set: [state: "executing"]])
+      |> Repo.update_all([])
+
+      assert Repo.reload!(task)
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source)
+      assert Repo.reload!(task)
+    end
+
+    test "can optionally delete currently executing tasks", %{source: source} do
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
+
+      from(Oban.Job, where: [id: ^job.id], update: [set: [state: "executing"]])
+      |> Repo.update_all([])
+
+      assert Repo.reload!(task)
+      assert :ok = SlowIndexingHelpers.delete_indexing_tasks(source, include_executing: true)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+  end
+
   describe "index_and_enqueue_download_for_media_items/1" do
     setup do
       stub(YtDlpRunnerMock, :run, fn _url, _opts, _ot, _addl_opts ->
@@ -202,6 +282,16 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
       assert %Ecto.Changeset{} = changeset
     end
 
+    test "passes the source's download options to the yt-dlp runner", %{source: source} do
+      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl_opts ->
+        assert {:output, "/tmp/test/media/%(title)S.%(ext)S"} in opts
+        assert {:remux_video, "mp4"} in opts
+        {:ok, source_attributes_return_fixture()}
+      end)
+
+      SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
+    end
+
     test "sets use_cookies if the source uses cookies" do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
         assert {:use_cookies, true} in addl_opts

test/pinchflat/sources_test.exs

@@ -418,6 +418,100 @@ defmodule Pinchflat.SourcesTest do
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
     end
 
+    test "updates with invalid data returns error changeset" do
+      source = source_fixture()
+
+      assert {:error, %Ecto.Changeset{}} =
+               Sources.update_source(source, @invalid_source_attrs)
+
+      assert source == Sources.get_source!(source.id)
+    end
+
+    test "updating will kickoff a metadata storage worker if the original_url changes" do
+      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+      source = source_fixture()
+      update_attrs = %{original_url: "https://www.youtube.com/channel/cba321"}
+
+      assert {:ok, %Source{} = source} = Sources.update_source(source, update_attrs)
+
+      assert_enqueued(worker: SourceMetadataStorageWorker, args: %{"id" => source.id})
+    end
+
+    test "updating will not kickoff a metadata storage worker other attrs change" do
+      source = source_fixture()
+      update_attrs = %{name: "some new name"}
+
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+
+      refute_enqueued(worker: SourceMetadataStorageWorker)
+    end
+  end
+
+  describe "update_source/3 when testing media download tasks" do
+    test "enabling the download_media attribute will schedule a download task" do
+      source = source_fixture(download_media: false)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+    end
+
+    test "disabling the download_media attribute will cancel the download task" do
+      source = source_fixture(download_media: true, enabled: true)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: false}
+      DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "enabling download_media will not schedule a task if the source is disabled" do
+      source = source_fixture(download_media: false, enabled: false)
+      _media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{download_media: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "disabling a source will cancel any pending download tasks" do
+      source = source_fixture(download_media: true, enabled: true)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: false}
+      DownloadingHelpers.enqueue_pending_download_tasks(source)
+
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+
+    test "enabling a source will schedule a download task if download_media is true" do
+      source = source_fixture(download_media: true, enabled: false)
+      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+    end
+
+    test "enabling a source will not schedule a download task if download_media is false" do
+      source = source_fixture(download_media: false, enabled: false)
+      _media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaDownloadWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaDownloadWorker)
+    end
+  end
+
+  describe "update_source/3 when testing slow indexing" do
     test "updating the index frequency to >0 will re-schedule the indexing task" do
       source = source_fixture()
       update_attrs = %{index_frequency_minutes: 123}
@@ -462,27 +556,47 @@ defmodule Pinchflat.SourcesTest do
       refute_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
     end
 
-    test "enabling the download_media attribute will schedule a download task" do
-      source = source_fixture(download_media: false)
-      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
-      update_attrs = %{download_media: true}
+    test "disabling a source will delete any pending tasks" do
+      source = source_fixture()
+      update_attrs = %{enabled: false}
+
+      {:ok, job} = Oban.insert(MediaCollectionIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
 
-      refute_enqueued(worker: MediaDownloadWorker)
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
-      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
     end
 
-    test "disabling the download_media attribute will cancel the download task" do
-      source = source_fixture(download_media: true)
-      media_item = media_item_fixture(source_id: source.id, media_filepath: nil)
-      update_attrs = %{download_media: false}
-      DownloadingHelpers.enqueue_pending_download_tasks(source)
+    test "updating the index frequency will not create a task if the source is disabled" do
+      source = source_fixture(enabled: false)
+      update_attrs = %{index_frequency_minutes: 123}
 
-      assert_enqueued(worker: MediaDownloadWorker, args: %{"id" => media_item.id})
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
-      refute_enqueued(worker: MediaDownloadWorker)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
     end
 
+    test "enabling a source will create a task if the index frequency is >0" do
+      source = source_fixture(enabled: false, index_frequency_minutes: 123)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: MediaCollectionIndexingWorker, args: %{"id" => source.id})
+    end
+
+    test "enabling a source will not create a task if the index frequency is 0" do
+      source = source_fixture(enabled: false, index_frequency_minutes: 0)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: MediaCollectionIndexingWorker)
+    end
+  end
+
+  describe "update_source/3 when testing fast indexing" do
     test "enabling fast_index will schedule a fast indexing task" do
       source = source_fixture(fast_index: false)
       update_attrs = %{fast_index: true}
@@ -503,15 +617,6 @@ defmodule Pinchflat.SourcesTest do
       refute_enqueued(worker: FastIndexingWorker)
     end
 
-    test "updates with invalid data returns error changeset" do
-      source = source_fixture()
-
-      assert {:error, %Ecto.Changeset{}} =
-               Sources.update_source(source, @invalid_source_attrs)
-
-      assert source == Sources.get_source!(source.id)
-    end
-
     test "fast_index forces the index frequency to be a default value" do
       source = source_fixture(%{fast_index: true})
       update_attrs = %{index_frequency_minutes: 0}
@@ -530,23 +635,43 @@ defmodule Pinchflat.SourcesTest do
       assert source.index_frequency_minutes == 0
     end
 
-    test "updating will kickoff a metadata storage worker if the original_url changes" do
-      expect(YtDlpRunnerMock, :run, &playlist_mock/4)
+    test "disabling a source will delete any pending tasks" do
       source = source_fixture()
-      update_attrs = %{original_url: "https://www.youtube.com/channel/cba321"}
+      update_attrs = %{enabled: false}
 
-      assert {:ok, %Source{} = source} = Sources.update_source(source, update_attrs)
-
-      assert_enqueued(worker: SourceMetadataStorageWorker, args: %{"id" => source.id})
-    end
-
-    test "updating will not kickoff a metadata storage worker other attrs change" do
-      source = source_fixture()
-      update_attrs = %{name: "some new name"}
+      {:ok, job} = Oban.insert(FastIndexingWorker.new(%{"id" => source.id}))
+      task = task_fixture(source_id: source.id, job_id: job.id)
 
       assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
 
-      refute_enqueued(worker: SourceMetadataStorageWorker)
+      assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
+    end
+
+    test "updating fast indexing will not create a task if the source is disabled" do
+      source = source_fixture(enabled: false, fast_index: false)
+      update_attrs = %{fast_index: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: FastIndexingWorker)
+    end
+
+    test "enabling a source will create a task if fast_index is true" do
+      source = source_fixture(enabled: false, fast_index: true)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      assert_enqueued(worker: FastIndexingWorker, args: %{"id" => source.id})
+    end
+
+    test "enabling a source will not create a task if fast_index is false" do
+      source = source_fixture(enabled: false, fast_index: false)
+      update_attrs = %{enabled: true}
+
+      refute_enqueued(worker: FastIndexingWorker)
+      assert {:ok, %Source{}} = Sources.update_source(source, update_attrs)
+      refute_enqueued(worker: FastIndexingWorker)
     end
   end
 

test/pinchflat/tasks_test.exs

@@ -247,7 +247,7 @@ defmodule Pinchflat.TasksTest do
       assert_raise Ecto.NoResultsError, fn -> Repo.reload!(task) end
     end
 
-    test "deletion can optionall include executing tasks" do
+    test "deletion can optionally include executing tasks" do
       source = source_fixture()
       task = task_fixture(source_id: source.id)
 

test/pinchflat/yt_dlp/media_collection_test.exs

@@ -35,6 +35,16 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
       assert {:error, "Big issue", 1} = MediaCollection.get_media_attributes_for_collection(@channel_url)
     end
 
+    test "passes long additional command options" do
+      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl_opts ->
+        assert :foo in opts
+
+        {:ok, ""}
+      end)
+
+      assert {:ok, _} = MediaCollection.get_media_attributes_for_collection(@channel_url, [:foo])
+    end
+
     test "passes additional args to runner" do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl_opts ->
         assert [{:output_filepath, filepath} | _] = addl_opts
@@ -56,7 +66,7 @@ defmodule Pinchflat.YtDlp.MediaCollectionTest do
       end
 
       assert {:ok, _} =
-               MediaCollection.get_media_attributes_for_collection(@channel_url, file_listener_handler: handler)
+               MediaCollection.get_media_attributes_for_collection(@channel_url, [], file_listener_handler: handler)
 
       assert_receive {:handler, filename}
       assert String.ends_with?(filename, ".json")

test/pinchflat/yt_dlp/media_test.exs

@@ -58,6 +58,64 @@ defmodule Pinchflat.YtDlp.MediaTest do
     end
   end
 
+  describe "get_downloadable_status/1" do
+    test "returns :downloadable if the media was never live" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "not_live"})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :downloadable if the media was live and has been processed" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "was_live"})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :downloadable if the media's live_status is nil" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => nil})}
+      end)
+
+      assert {:ok, :downloadable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media is currently live" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_live"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media is scheduled to be live" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "is_upcoming"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns :ignorable if the media was live but hasn't been processed" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "post_live"})}
+      end)
+
+      assert {:ok, :ignorable} = Media.get_downloadable_status(@media_url)
+    end
+
+    test "returns an error if the downloadable status can't be determined" do
+      expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot ->
+        {:ok, Phoenix.json_library().encode!(%{"live_status" => "what_tha"})}
+      end)
+
+      assert {:error, "Unknown live status: what_tha"} = Media.get_downloadable_status(@media_url)
+    end
+  end
+
   describe "download_thumbnail/2" do
     test "calls the backend runner with the expected arguments" do
       expect(YtDlpRunnerMock, :run, fn @media_url, opts, ot, _addl ->
@@ -120,13 +178,22 @@ defmodule Pinchflat.YtDlp.MediaTest do
       assert {:ok, _} = Media.get_media_attributes(@media_url)
     end
 
+    test "passes along additional command options" do
+      expect(YtDlpRunnerMock, :run, fn _url, opts, _ot, _addl ->
+        assert [:simulate, :skip_download, :custom_arg] = opts
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      assert {:ok, _} = Media.get_media_attributes(@media_url, [:custom_arg])
+    end
+
     test "passes along additional options" do
       expect(YtDlpRunnerMock, :run, fn _url, _opts, _ot, addl ->
         assert [addl_arg: true] = addl
         {:ok, media_attributes_return_fixture()}
       end)
 
-      assert {:ok, _} = Media.get_media_attributes(@media_url, addl_arg: true)
+      assert {:ok, _} = Media.get_media_attributes(@media_url, [], addl_arg: true)
     end
 
     test "returns the error straight through when the command fails" do
@@ -139,7 +206,7 @@ defmodule Pinchflat.YtDlp.MediaTest do
   describe "indexing_output_template/0" do
     test "contains all the greatest hits" do
       attrs =
-        ~w(id title live_status original_url description aspect_ratio duration upload_date timestamp playlist_index)a
+        ~w(id title live_status original_url description aspect_ratio duration upload_date timestamp playlist_index filename)a
 
       formatted_attrs = "%(.{#{Enum.join(attrs, ",")}})j"
 
@@ -159,7 +226,8 @@ defmodule Pinchflat.YtDlp.MediaTest do
         "duration" => 60,
         "upload_date" => "20210101",
         "timestamp" => 1_600_000_000,
-        "playlist_index" => 1
+        "playlist_index" => 1,
+        "filename" => "TiZPUDkDYbk.mp4"
       }
 
       assert %Media{
@@ -171,7 +239,8 @@ defmodule Pinchflat.YtDlp.MediaTest do
                short_form_content: false,
                uploaded_at: ~U[2020-09-13 12:26:40Z],
                duration_seconds: 60,
-               playlist_index: 1
+               playlist_index: 1,
+               predicted_media_filepath: "TiZPUDkDYbk.mp4"
              } == Media.response_to_struct(response)
     end
 

test/pinchflat_web/controllers/media_profile_controller_test.exs

@@ -79,6 +79,15 @@ defmodule PinchflatWeb.MediaProfileControllerTest do
 
       refute html_response(conn, 200) =~ "MENU"
     end
+
+    test "preloads some attributes when using a template", %{conn: conn} do
+      profile = media_profile_fixture(name: "My first profile", download_subs: true, sub_langs: "de")
+
+      conn = get(conn, ~p"/media_profiles/new", %{"template_id" => profile.id})
+      assert html_response(conn, 200) =~ "New Media Profile"
+      assert html_response(conn, 200) =~ profile.sub_langs
+      refute html_response(conn, 200) =~ profile.name
+    end
   end
 
   describe "edit media_profile" do

test/pinchflat_web/controllers/source_controller_test.exs

@@ -34,27 +34,10 @@ defmodule PinchflatWeb.SourceControllerTest do
   end
 
   describe "index" do
-    test "lists all sources", %{conn: conn} do
-      source = source_fixture()
+    # Most of the tests are in `index_table_list_test.exs`
+    test "returns 200", %{conn: conn} do
       conn = get(conn, ~p"/sources")
-
       assert html_response(conn, 200) =~ "Sources"
-      assert html_response(conn, 200) =~ source.custom_name
-    end
-
-    test "omits sources that have marked_for_deletion_at set", %{conn: conn} do
-      source = source_fixture(marked_for_deletion_at: DateTime.utc_now())
-      conn = get(conn, ~p"/sources")
-
-      refute html_response(conn, 200) =~ source.custom_name
-    end
-
-    test "omits sources who's media profile has marked_for_deletion_at set", %{conn: conn} do
-      media_profile = media_profile_fixture(marked_for_deletion_at: DateTime.utc_now())
-      source = source_fixture(media_profile_id: media_profile.id)
-      conn = get(conn, ~p"/sources")
-
-      refute html_response(conn, 200) =~ source.custom_name
     end
   end
 

test/pinchflat_web/controllers/sources/index_table_live_test.exs

@@ -0,0 +1,55 @@
+defmodule PinchflatWeb.Sources.IndexTableLiveTest do
+  use PinchflatWeb.ConnCase
+
+  import Phoenix.LiveViewTest
+  import Pinchflat.SourcesFixtures
+  import Pinchflat.ProfilesFixtures
+
+  alias Pinchflat.Sources.Source
+  alias PinchflatWeb.Sources.IndexTableLive
+
+  describe "initial rendering" do
+    test "lists all sources", %{conn: conn} do
+      source = source_fixture()
+
+      {:ok, _view, html} = live_isolated(conn, IndexTableLive)
+
+      assert html =~ source.custom_name
+    end
+
+    test "omits sources that have marked_for_deletion_at set", %{conn: conn} do
+      source = source_fixture(marked_for_deletion_at: DateTime.utc_now())
+
+      {:ok, _view, html} = live_isolated(conn, IndexTableLive)
+
+      refute html =~ source.custom_name
+    end
+
+    test "omits sources who's media profile has marked_for_deletion_at set", %{conn: conn} do
+      media_profile = media_profile_fixture(marked_for_deletion_at: DateTime.utc_now())
+      source = source_fixture(media_profile_id: media_profile.id)
+
+      {:ok, _view, html} = live_isolated(conn, IndexTableLive)
+
+      refute html =~ source.custom_name
+    end
+  end
+
+  describe "when a source is enabled or disabled" do
+    test "updates the source's enabled status", %{conn: conn} do
+      source = source_fixture(enabled: true)
+      {:ok, view, _html} = live_isolated(conn, IndexTableLive)
+
+      params = %{
+        "event" => "toggle_enabled",
+        "id" => source.id,
+        "value" => "false"
+      }
+
+      # Send an event to the server directly
+      render_change(view, "formless-input", params)
+
+      assert %{enabled: false} = Repo.get!(Source, source.id)
+    end
+  end
+end

test/pinchflat_web/controllers/sources/media_item_table_live_test.exs

@@ -6,7 +6,7 @@ defmodule PinchflatWeb.Sources.MediaItemTableLiveTest do
   import Pinchflat.SourcesFixtures
   import Pinchflat.ProfilesFixtures
 
-  alias Pinchflat.Sources.MediaItemTableLive
+  alias PinchflatWeb.Sources.MediaItemTableLive
 
   setup do
     source = source_fixture()

test/support/fixtures/sources_fixtures.ex

@@ -20,6 +20,7 @@ defmodule Pinchflat.SourcesFixtures do
         Enum.into(
           attrs,
           %{
+            enabled: true,
             collection_name: "Source ##{:rand.uniform(1_000_000)}",
             collection_id: Base.encode16(:crypto.hash(:md5, "#{:rand.uniform(1_000_000)}")),
             collection_type: "channel",