remove redundant latest tags

set restart policy to unless-stopped
browser extension as prefered cookie sync method
2026-08-09 12:29:17 +00:00 · 2022-07-03 18:20:30 +07:00 · 2022-07-03 17:23:02 +07:00 · 2022-07-03 16:46:45 +07:00 · 2022-07-03 16:09:09 +07:00 · 2022-07-03 16:08:30 +07:00
48 changed files with 1456 additions and 415 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -11,7 +11,7 @@ If the issue doesn't move forward due to a lack of response, I assume it's solve

 ## Wiki

-The wiki is where all user functions are explained in detail. These pages are mirrored into the **docs** folder of the repo. This allows for pull requests and all other features like regular code. Make any changes there, and I'll sync them with the wiki tab.
+The wiki is where all user functions are documented in detail. These pages are mirrored into the **docs** folder of the repo. This allows for pull requests and all other features like regular code. Make any changes there, and I'll sync them with the wiki tab.

 ## Development Environment

@@ -19,7 +19,7 @@ I have learned the hard way, that working on a dockerized application outside of

 This is my setup I have landed on, YMMV:
 - Clone the repo, work on it with your favorite code editor in your local filesystem. *testing* branch is the where all the changes are happening, might be unstable and is WIP.
- Then I have a VM on KVM hypervisor running standard Ubuntu Server LTS with docker installed. The VM keeps my projects separate and offers convenient snapshot functionality. The VM also offers ways to simulate lowend environments by limiting CPU cores and memory. But you could also just run docker on your host system.
+- Then I have a VM running standard Ubuntu Server LTS with docker installed. The VM keeps my projects separate and offers convenient snapshot functionality. The VM also offers ways to simulate lowend environments by limiting CPU cores and memory. You can use this [Ansible Docker Ubuntu](https://github.com/bbilly1/ansible-playbooks) playbook to get started quickly. But you could also just run docker on your host system.
 - The `Dockerfile` is structured in a way that the actual application code is in the last layer so rebuilding the image with only code changes utilizes the build cache for everything else and will just take a few seconds.
 - Take a look at the `deploy.sh` file. I have my local DNS resolve `tubearchivist.local` to the IP of the VM for convenience. To deploy the latest changes and rebuild the application to the testing VM run:
 ```bash
@@ -27,16 +27,16 @@ This is my setup I have landed on, YMMV:
 ```
 - The command above will call the docker build command with `--build-arg INSTALL_DEBUG=1` to install additional useful debug tools.
 - The `test` argument takes another optional argument to build for a specific architecture valid options are: `amd64`, `arm64` and `multi`, default is `amd64`.
- This `deploy.sh` file is not meant to be universally usable for every possible environment but could serve as an idea on how to automatically rebuild containers to test changes - customize to your liking. 
+- This `deploy.sh` script is not meant to be universally usable for every possible environment but could serve as an idea on how to automatically rebuild containers to test changes - customize to your liking. 

 ## Working with Elasticsearch
 Additionally to the required services as listed in the example docker-compose file, the **Dev Tools** of [Kibana](https://www.elastic.co/guide/en/kibana/current/docker.html) are invaluable for running and testing Elasticsearch queries.  

-If you want to run queries in on the Elasticsearch container directly from your host with for example `curl` or something like *postman*, you might want to **publish** the port 9200 instead of just **exposing** it.
+If you want to run queries on the Elasticsearch container directly from your host with for example `curl` or something like *postman*, you might want to **publish** the port 9200 instead of just **exposing** it.

 ## Implementing a new feature

-Do you see anything on the roadmap that you would like to take a closer look at but you are not sure, what's the best way to tackle that? Or anything not on there yet you'd like to implement but are not sure how? Open up an issue and we try to find a solution together.
+Do you see anything on the roadmap that you would like to take a closer look at but you are not sure, what's the best way to tackle that? Or anything not on there yet you'd like to implement but are not sure how? Reach out on Discord and we'll look into it together.

 ## Making changes

@@ -53,10 +53,10 @@ If you want to see what's in your container, checkout the matching release tag.

 ## Code formatting and linting

-To keep things clean and consistent for everybody, there is a github action setup to lint and check the changes. You can test your code locally first if you want. For example if you made changes in the **download** module, run
+To keep things clean and consistent for everybody, there is a github action setup to lint and check the changes. You can test your code locally first if you want. For example if you made changes in the **video** module, run

 ```shell
-./deploy.sh validate tubearchivist/home/src/download.py
+./deploy.sh validate tubearchivist/home/src/index/video.py
 ```

-to validate your changes. If you omit the path, all the project files will get checked. This is subject to change as the codebase improves. 
+to validate your changes. If you omit the path, all the project files will get checked. This is subject to change as the codebase improves. 
--- a/51
+++ b/51
@@ -3,11 +3,34 @@


 # First stage to build python wheel
-FROM python:3.10.4-slim-bullseye AS builder
+FROM python:3.10.5-slim-bullseye AS builder
 ARG TARGETPLATFORM

 RUN apt-get update
-RUN apt-get install -y --no-install-recommends build-essential gcc curl
+RUN apt-get install -y --no-install-recommends build-essential gcc
+
+# install requirements
+COPY ./tubearchivist/requirements.txt /requirements.txt
+RUN pip install --user -r requirements.txt
+
+# build final image
+FROM python:3.10.5-slim-bullseye as tubearchivist
+
+ARG TARGETPLATFORM
+ARG INSTALL_DEBUG
+
+ENV PYTHONUNBUFFERED 1
+
+# copy build requirements
+COPY --from=builder /root/.local /root/.local
+ENV PATH=/root/.local/bin:$PATH
+
+# install distro packages needed
+RUN apt-get clean && apt-get -y update && apt-get -y install --no-install-recommends \
+    nginx \
+    atomicparsley \
+    curl \
+    xz-utils && rm -rf /var/lib/apt/lists/*

 # get newest patched ffmpeg and ffprobe builds for amd64 fall back to repo ffmpeg for arm64
 RUN if [ "$TARGETPLATFORM" = "linux/amd64" ] ; then \
@@ -23,30 +46,6 @@ RUN if [ "$TARGETPLATFORM" = "linux/amd64" ] ; then \
        apt-get -y update && apt-get -y install --no-install-recommends ffmpeg && rm -rf /var/lib/apt/lists/* \
    ; fi

-# install requirements
-COPY ./tubearchivist/requirements.txt /requirements.txt
-RUN pip install --user -r requirements.txt
-
-# build final image
-FROM python:3.10.4-slim-bullseye as tubearchivist
-
-ARG TARGETPLATFORM
-ARG INSTALL_DEBUG
-
-ENV PYTHONUNBUFFERED 1
-
-# copy build requirements
-COPY --from=builder /root/.local /root/.local
-COPY --from=builder /usr/bin/ffmpeg /usr/bin/ffmpeg
-COPY --from=builder /usr/bin/ffprobe /usr/bin/ffprobe
-ENV PATH=/root/.local/bin:$PATH
-
-# install distro packages needed
-RUN apt-get clean && apt-get -y update && apt-get -y install --no-install-recommends \
-    nginx \
-    atomicparsley \
-    curl && rm -rf /var/lib/apt/lists/*
-
 # install debug tools for testing environment
 RUN if [ "$INSTALL_DEBUG" ] ; then \
        apt-get -y update && apt-get -y install --no-install-recommends \
--- a/README.md
+++ b/README.md
@@ -1,15 +1,19 @@
 ![Tube Archivist](assets/tube-archivist-banner.jpg?raw=true "Tube Archivist Banner")  

-<center><h1>Your self hosted YouTube media server</h1></center>
-
-Tube Archivist has a new home: https://github.com/tubearchivist/tubearchivist
+<h1 align="center">Your self hosted YouTube media server</h1>
+<div align="center">
+<a href="https://github.com/bbilly1/tilefy" target="_blank"><img src="https://tiles.tilefy.me/t/tubearchivist-docker.png" alt="tubearchivist-docker" title="Tube Archivist Docker Pulls" height="50" width="200"/></a>
+<a href="https://github.com/bbilly1/tilefy" target="_blank"><img src="https://tiles.tilefy.me/t/tubearchivist-github-star.png" alt="tubearchivist-github-star" title="Tube Archivist GitHub Stars" height="50" width="200"/></a>
+<a href="https://github.com/bbilly1/tilefy" target="_blank"><img src="https://tiles.tilefy.me/t/tubearchivist-github-forks.png" alt="tubearchivist-github-forks" title="Tube Archivist GitHub Forks" height="50" width="200"/></a>
+</div>

 ## Table of contents:
-* [Wiki](https://github.com/tubearchivist/tubearchivist/wiki) for a detailed documentation, with [FAQ](https://github.com/tubearchivist/tubearchivist/wiki/FAQ)
+* [Wiki](https://github.com/tubearchivist/tubearchivist/wiki) with [FAQ](https://github.com/tubearchivist/tubearchivist/wiki/FAQ)
 * [Core functionality](#core-functionality)
 * [Screenshots](#screenshots)
 * [Problem Tube Archivist tries to solve](#problem-tube-archivist-tries-to-solve)
 * [Connect](#connect)
+* [Extended Universe](#extended-universe)
 * [Installing and updating](#installing-and-updating)
 * [Getting Started](#getting-started)
 * [Potential pitfalls](#potential-pitfalls)
@@ -52,6 +56,10 @@ Once your YouTube video collection grows, it becomes hard to search and find a s
 - [Discord](https://discord.gg/AFwz8nE7BK): Connect with us on our Discord server.
 - [r/TubeArchivist](https://www.reddit.com/r/TubeArchivist/): Join our Subreddit.

+## Extended Universe
+- [Browser Extension](https://github.com/tubearchivist/browser-extension) Tube Archivist Companion, for [Firefox](https://addons.mozilla.org/addon/tubearchivist-companion/) and [Chrome](https://chrome.google.com/webstore/detail/tubearchivist-companion/jjnkmicfnfojkkgobdfeieblocadmcie)
+- [Tube Archivist Metrics](https://github.com/tubearchivist/tubearchivist-metrics) to create statistics in Prometheus/OpenMetrics format.
+
 ## Installing and updating
 Take a look at the example `docker-compose.yml` file provided. Use the *latest* or the named semantic version tag. The *unstable* tag is for intermediate testing and as the name implies, is **unstable** and not be used on your main installation but in a [testing environment](CONTRIBUTING.md).  

@@ -134,7 +142,9 @@ chown 1000:0 /path/to/mount/point
 This will match the permissions with the **UID** and **GID** of elasticsearch within the container and should fix the issue.

 ### Disk usage
-The Elasticsearch index will turn to *read only* if the disk usage of the container goes above 95% until the usage drops below 90% again. Similar to that, TubeArchivist will become all sorts of messed up when running out of disk space. There are some error messages in the logs when that happens, but it's best to make sure to have enough disk space before starting to download.
+The Elasticsearch index will turn to *read only* if the disk usage of the container goes above 95% until the usage drops below 90% again, you will see error messages like `disk usage exceeded flood-stage watermark`, [link](https://github.com/tubearchivist/tubearchivist#disk-usage).  
+
+Similar to that, TubeArchivist will become all sorts of messed up when running out of disk space. There are some error messages in the logs when that happens, but it's best to make sure to have enough disk space before starting to download.

 ## Getting Started
 1. Go through the **settings** page and look at the available options. Particularly set *Download Format* to your desired video quality before downloading. **Tube Archivist** downloads the best available quality by default. To support iOS or MacOS and some other browsers a compatible format must be specified. For example:
@@ -153,14 +163,13 @@ We have come far, nonetheless we are not short of ideas on how to improve and ex
 - [ ] Podcast mode to serve channel as mp3
 - [ ] Implement [PyFilesystem](https://github.com/PyFilesystem/pyfilesystem2) for flexible video storage
 - [ ] Implement [Apprise](https://github.com/caronc/apprise) for notifications ([#97](https://github.com/tubearchivist/tubearchivist/issues/97))
- [ ] Add passing browser cookies to yt-dlp ([#199](https://github.com/tubearchivist/tubearchivist/issues/199))
 - [ ] User created playlists, random and repeat controls ([#108](https://github.com/tubearchivist/tubearchivist/issues/108), [#220](https://github.com/tubearchivist/tubearchivist/issues/220))
 - [ ] Auto play or play next link ([#226](https://github.com/tubearchivist/tubearchivist/issues/226))
 - [ ] Show similar videos on video page
 - [ ] Multi language support
 - [ ] Show total video downloaded vs total videos available in channel
- [ ] Make items in grid row configurable to use more of the screen
 - [ ] Add statistics of index
+- [ ] Download speed schedule ([#198](https://github.com/tubearchivist/tubearchivist/issues/198))
 - [ ] Implement complete offline media file import from json file ([#138](https://github.com/tubearchivist/tubearchivist/issues/138))
 - [ ] Filter and query in search form, search by url query ([#134](https://github.com/tubearchivist/tubearchivist/issues/134), [#139](https://github.com/tubearchivist/tubearchivist/issues/139))
 - [ ] Auto ignore videos by keyword ([#163](https://github.com/tubearchivist/tubearchivist/issues/163))
@@ -168,6 +177,8 @@ We have come far, nonetheless we are not short of ideas on how to improve and ex
 - [ ] Download video comments

 Implemented:
+- [X] Make items in grid row configurable to use more of the screen [2022-06-04]
+- [X] Add passing browser cookies to yt-dlp [2022-05-08]
 - [X] Add [SponsorBlock](https://sponsor.ajay.app/) integration [2022-04-16]
 - [X] Implement per channel settings [2022-03-26]
 - [X] Subtitle download & indexing [2022-02-13]
--- a/deploy.sh
+++ b/deploy.sh
@@ -33,7 +33,7 @@ function sync_blackhole {
        . -e ssh "$host":tubearchivist

    echo "$PASS" | ssh "$host" 'sudo -S docker buildx build --platform linux/amd64 -t bbilly1/tubearchivist:latest tubearchivist --load 2>/dev/null'
-    echo "$PASS" | ssh "$host" 'sudo -S docker-compose up -d 2>/dev/null'
+    echo "$PASS" | ssh "$host" 'sudo -S docker compose up -d 2>/dev/null'

 }

@@ -69,7 +69,7 @@ function sync_test {
    fi

    ssh "$host" "docker buildx build --build-arg INSTALL_DEBUG=1 --platform $platform -t bbilly1/tubearchivist:latest tubearchivist --load"
-    ssh "$host" 'docker-compose -f docker/docker-compose.yml up -d'
+    ssh "$host" 'docker compose -f docker/docker-compose.yml up -d'

 }

@@ -144,6 +144,7 @@ function sync_unstable {
 }


+# new function, sync only tag, build with build server
 function sync_docker {

    # check things
@@ -152,13 +153,40 @@ function sync_docker {
        return
    fi

+    echo "latest tags:"
+    git tag | tail -n 5 | sort -r
+
+    printf "\ncreate new version:\n"
+    read -r VERSION
+
+    echo "push new tag: $VERSION?"
+    read -rn 1
+
+    # create release tag
+    echo "commits since last version:"
+    git log "$(git describe --tags --abbrev=0)"..HEAD --oneline
+    git tag -a "$VERSION" -m "new release version $VERSION"
+    git push origin "$VERSION"
+
+}
+
+
+# old builder, sync tag, build and push locally
+function sync_docker_old {
+
+    # check things
+    if [[ $(git branch --show-current) != 'master' ]]; then
+        echo 'you are not on master, dummy!'
+        return
+    fi
+
    if [[ $(systemctl is-active docker) != 'active' ]]; then
        echo "starting docker"
        sudo systemctl start docker
    fi

    echo "latest tags:"
-    git tag | tail -n 10
+    git tag | tail -n 5 | sort -r

    printf "\ncreate new version:\n"
    read -r VERSION
@@ -176,7 +204,7 @@ function sync_docker {
    echo "commits since last version:"
    git log "$(git describe --tags --abbrev=0)"..HEAD --oneline
    git tag -a "$VERSION" -m "new release version $VERSION"
-    git push all "$VERSION"
+    git push origin "$VERSION"

 }

@@ -191,7 +219,6 @@ elif [[ $1 == "validate" ]]; then
    validate "$2"
 elif [[ $1 == "docker" ]]; then
    sync_docker
-    sync_unstable
 elif [[ $1 == "unstable" ]]; then
    sync_unstable
 elif [[ $1 == "es" ]]; then
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -3,8 +3,8 @@ version: '3.3'
 services:
  tubearchivist:
    container_name: tubearchivist
-    restart: always
-    image: bbilly1/tubearchivist:latest
+    restart: unless-stopped
+    image: bbilly1/tubearchivist
    ports:
      - 8000:8000
    volumes:
@@ -23,9 +23,9 @@ services:
      - archivist-es
      - archivist-redis
  archivist-redis:
-    image: redislabs/rejson:latest          # for arm64 use bbilly1/rejson
+    image: redislabs/rejson                 # for arm64 use bbilly1/rejson
    container_name: archivist-redis
-    restart: always
+    restart: unless-stopped
    expose:
      - "6379"
    volumes:
@@ -33,9 +33,9 @@ services:
    depends_on:
      - archivist-es
  archivist-es:
-    image: bbilly1/tubearchivist-es         # only for amd64, or use official es 7.17.2
+    image: bbilly1/tubearchivist-es         # only for amd64, or use official es 7.17.4
    container_name: archivist-es
-    restart: always
+    restart: unless-stopped
    environment:
      - "xpack.security.enabled=true"
      - "ELASTIC_PASSWORD=verysecret"       # matching Elasticsearch password
--- a/docker_assets/run.sh
+++ b/docker_assets/run.sh
@@ -5,13 +5,14 @@ if [[ -z "$ELASTIC_USER" ]]; then
    export ELASTIC_USER=elastic
 fi

-ENV_VARS=("TA_USERNAME" "TA_PASSWORD" "ELASTIC_PASSWORD" "ELASTIC_USER")
-for each in "${ENV_VARS[@]}"; do
-    if ! [[ -v $each ]]; then
-        echo "missing environment variable $each"
-        exit 1
-    fi
-done
+cachedir=/cache
+[[ -d $cachedir ]] || cachedir=.
+lockfile=${cachedir}/initsu.lock
+
+required="Missing required environment variable"
+[[ -f $lockfile ]] || : "${TA_USERNAME:?$required}"
+: "${TA_PASSWORD:?$required}"
+: "${ELASTIC_PASSWORD:?$required}"

 # ugly nginx and uwsgi port overwrite with env vars
 if [[ -n "$TA_PORT" ]]; then
@@ -39,12 +40,27 @@ done
 # start python application
 python manage.py makemigrations
 python manage.py migrate
-export DJANGO_SUPERUSER_PASSWORD=$TA_PASSWORD && \
-    python manage.py createsuperuser --noinput --name "$TA_USERNAME"
+
+if [[ -f $lockfile ]]; then
+    echo -e "\e[33;1m[WARNING]\e[0m This is not the first run! Skipping" \
+        "superuser creation.\nTo force it, remove $lockfile"
+else
+    export DJANGO_SUPERUSER_PASSWORD=$TA_PASSWORD
+    output="$(python manage.py createsuperuser --noinput --name "$TA_USERNAME" 2>&1)"
+
+    case "$output" in
+        *"Superuser created successfully"*)
+            echo "$output" && touch $lockfile ;;
+        *"That name is already taken."*)
+            echo "Superuser already exists. Creation will be skipped on next start."
+            touch $lockfile ;;
+        *) echo "$output" && exit 1
+    esac
+fi

 python manage.py collectstatic --noinput -c
 nginx &
 celery -A home.tasks worker --loglevel=INFO &
 celery -A home beat --loglevel=INFO \
-    -s "${BEAT_SCHEDULE_PATH:-/cache/celerybeat-schedule}" &
+    -s "${BEAT_SCHEDULE_PATH:-${cachedir}/celerybeat-schedule}" &
 uwsgi --ini uwsgi.ini
--- a/docs/Downloads.md
+++ b/docs/Downloads.md
@@ -33,11 +33,9 @@ Every video in the download queue has two buttons:
 - **Ignore**: This will remove that video from the download queue and this video will not get added again, even when you **Rescan Subscriptions**.
 - **Download now**: This will give priority to this video. If the download process is already running, the prioritized video will get downloaded as soon as the current video is finished. If there is no download process running, this will start downloading this single video and stop after that.  

-The button **Delete all queued** will delete all pending videos from the download queue.
-
 You can flip the view by activating **Show Only Ignored Videos**. This will show all videos you have previously *ignored*.  
 Every video in the ignored list has two buttons:
 - **Forget**: This will delete the item form the ignored list.
 - **Add to Queue**: This will add the ignored video back to the download queue.  

-The button **Delete all ignored** will delete all videos you have previously ignored.
+You can delete your download queue from the [Settings](Settings#actions) page.
--- a/docs/Home.md
+++ b/docs/Home.md
@@ -28,4 +28,4 @@ Table of contents:

 An empty checkbox icon <img src="assets/icon-unseen.png?raw=true" alt="unseen icon" width="20px" style="margin:0 5px;"> will show for videos you haven't marked as watched. Click on it and the icon will change to a filled checkbox <img src="assets/icon-seen.png?raw=true" alt="seen icon" width="20px" style="margin:0 5px;"> indicating it as watched - click again to revert.

-When available the <img src="assets/icon-gridview.png?raw=true" alt="gridview icon" width="20px" style="margin:0 5px;"> gridview icon will display the list in a grid, the <img src="assets/icon-listview.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> listview icon will arrange the items in a list. The sort icon <img src="assets/icon-sort.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> will open additional sort options.
+When available the <img src="assets/icon-gridview.png?raw=true" alt="gridview icon" width="20px" style="margin:0 5px;"> gridview icon will display the list in a grid. A grid row holds 3 items by default, use the <img src="assets/icon-add.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> icon to add more or the <img src="assets/icon-substract.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> icon to remove items per row, depending on your screen size. The <img src="assets/icon-listview.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> listview icon will arrange the items in a list. The sort icon <img src="assets/icon-sort.png?raw=true" alt="listview icon" width="20px" style="margin:0 5px;"> will open additional sort options.
--- a/docs/Installation.md
+++ b/docs/Installation.md
@@ -54,3 +54,16 @@ It's finally time to set up TubeArchivist!

 ### From there, you should be able to start up your containers and you're good to go!
 If you're still having trouble, join us on [discord](https://discord.gg/AFwz8nE7BK) and come to the #unraid channel.
+
+<br />
+<br />
+
+## Truenas Scale 
+
+Truenas Scale can be a bit confusing, with its k3s kubernetes implementation. 
+
+However, there is a step by step guide available for it's users here:
+
+https://heavysetup.info/applications/tube-archivist/dataset/
+
+- Ensure you are navigating the columns under `Tube Archivist` on the left hand side of the screen
--- a/docs/Settings.md
+++ b/docs/Settings.md
@@ -32,6 +32,32 @@ Additional settings passed to yt-dlp.
 - **Source Settings**: User created subtitles are provided from the uploader and are usually the video script. Auto generated is from YouTube, quality varies, particularly for auto translated tracks.
 - **Index Settings**: Enabling subtitle indexing will add the lines to Elasticsearch and will make subtitles searchable. This will increase the index size and is not recommended on low-end hardware.

+## Cookie
+Importing your YouTube Cookie into Tube Archivist allows yt-dlp to bypass age restrictions, gives access to private videos and your *watch later* or *liked videos*.
+
+### Security concerns
+Cookies are used to store your session and contain your access token to your google account, this information can be used to take over your account. Treat that data with utmost care as you would any other password or credential. *Tube Archivist* stores your cookie in Redis and will automatically append it to yt-dlp for every request.
+
+### Auto import
+Easiest way to import your cookie is to use the **Tube Archivist Companion** [browser extension](https://github.com/tubearchivist/browser-extension) for Firefox and Chrome.
+
+### Alternative Manual Export your cookie
+- Install **Cookies.txt** addon for [chrome](https://chrome.google.com/webstore/detail/get-cookiestxt/bgaddhkoddajcdgocldbbfleckgcbcid) or [firefox](https://addons.mozilla.org/firefox/addon/cookies-txt).
+- Visit YouTube and login with whichever YouTube account you wish to use to generate the cookies.
+- Click on the extension icon in the toolbar - it will drop down showing the active cookies for YT.
+- Click Export to export the cookies, filename is by default *cookies.google.txt*.
+
+### Alternative Manual Import your cookie
+Place the file *cookies.google.txt* into the *cache/import* folder of Tube Archivist and enable the cookie import. Once you click on *Update Application Configurations* to save your changes, your cookie will get imported and stored internally.
+
+Once imported, a **Validate Cookie File** button will show, where you can confirm if your cookie is working or not.
+
+### Use your cookie
+Once imported, additionally to the advantages above, your [Watch Later](https://www.youtube.com/playlist?list=WL) and [Liked Videos](https://www.youtube.com/playlist?list=LL) become a regular playlist you can download and subscribe to as any other [playlist](Playlists).
+
+### Limitation
+There is only one cookie per Tube Archivist instance, this will be shared between all users.
+
 ## Integrations
 All third party integrations of TubeArchivist will **always** be *opt in*.
 - **API**: Your access token for the Tube Archivist API.
@@ -72,7 +98,7 @@ That's the equivalent task as run from the downloads page looking through your c
 Start downloading all videos currently in the download queue.

 ## Refresh Metadata
-Rescan videos, channels and playlists on youtube and update metadata periodically. This will also deactivate an item and exclude it from future refreshes if the link on YouTube is no longer available. This task is meant to be run once per day, set your schedule accordingly.
+Rescan videos, channels and playlists on youtube and update metadata periodically. This will also refresh your subtitles based on your current settings. If an item is no longer available on YouTube, this will deactivate it and exclude it from future refreshes. This task is meant to be run once per day, set your schedule accordingly.

 The field **Refresh older than x days** takes a number where TubeArchivist will consider an item as *outdated*. This value is used to calculate how many items need to be refreshed today based on the total indexed. This will spread out the requests to YouTube. Sensible value here is **90** days.

@@ -86,6 +112,9 @@ Create a zip file of the metadata and select **Max auto backups to keep** to aut
 # Actions
 Additional database functionality.

+## Delete download queue
+The button **Delete all queued** will delete all pending videos from the download queue. The button **Delete all ignored** will delete all videos you have previously ignored.
+
 ## Manual Media Files Import
 So far this depends on the video you are trying to import to be still available on YouTube to get the metadata. Add the files you'd like to import to the */cache/import* folder. Then start the process from the settings page *Manual Media Files Import*. Make sure to follow one of the two methods below.

--- a/docs/assets/icon-substract.png
+++ b/docs/assets/icon-substract.png
--- a/tubearchivist/api/README.md
+++ b/tubearchivist/api/README.md
@@ -1,6 +1,9 @@
 # TubeArchivist API
 Documentation of available API endpoints.  
-**Note: This is very early alpha and will change!**
+
+Note:  
+- This is very early stages and will change!
+- Check the commit history to see if a documented feature is already in your release

 ## Authentication
 API token will get automatically created, accessible on the settings page. Token needs to be passed as an authorization header with every request. Additionally session based authentication is enabled too: When you are logged into your TubeArchivist instance, you'll have access to the api in the browser for testing.
@@ -20,6 +23,19 @@ headers = {"Authorization": "Token xxxxxxxxxx"}
 response = requests.get(url, headers=headers)
 ```

+## Pagination
+The list views return a paginate object with the following keys:
+- page_size: int current page size set in config
+- page_from: int first result idx
+- prev_pages: array of ints of previous pages, if available
+- current_page: int current page from query
+- max_hits: reached: bool if max of 10k results is reached
+- last_page: int of last page link
+- next_pages: array of ints of next pages
+- total_hits: int total results
+
+Pass page number as a query parameter: `page=2`. Defaults to *0*, `page=1` is redundant and falls back to *0*. If a page query doesn't return any results, you'll get `HTTP 404 Not Found`.
+
 ## Login View
 Return token and user ID for username and password:  
 POST /api/login
@@ -123,14 +139,23 @@ POST /api/channel/
 ## Channel Item View
 /api/channel/\<channel_id>/

+## Channel Videos View
+/api/channel/\<channel_id>/video/
+
 ## Playlist List View
 /api/playlist/

 ## Playlists Item View
 /api/playlist/\<playlist_id>/

+## Playlist Videos View
+/api/playlist/\<playlist_id>/video/
+
 ## Download Queue List View
-/api/download/
+GET /api/download/
+
+Parameter:
+- filter: pending, ignore

 ### Add list of videos to download queue
 POST /api/download/
@@ -142,9 +167,30 @@ POST /api/download/
 }
 ```

-## Download Queue Item View
-/api/download/\<video_id>/
+### Delete download queue items by filter
+DELETE /api/download/?filter=ignore  
+DELETE /api/download/?filter=pending

+## Download Queue Item View
+GET /api/download/\<video_id>/  
+POST /api/download/\<video_id>/
+
+Ignore video in download queue:
+```json
+{
+    "status": "ignore"
+}
+```
+
+Add to queue previously ignored video:
+```json
+{
+    "status": "pending"
+}
+```
+
+DELETE /api/download/\<video_id>/  
+Forget or delete from download queue

 ## Ping View
 Validate your connection with the API  
@@ -157,3 +203,73 @@ When valid returns message with user id:
    "user": 1
 }
 ```
+
+## Task View
+GET /api/task/
+POST /api/task/
+
+Check if there is an ongoing task:
+GET /api/task/
+
+Returns:
+```json
+{
+    "rescan": false,
+    "downloading": false
+}
+```
+
+Start a background task  
+POST /api/task/
+```json
+{
+    "run": "task_name"
+}
+```
+
+List of valid task names:
+- **download_pending**: Start the download queue
+- **rescan_pending**: Rescan your subscriptions
+
+
+## Cookie View
+Check your youtube cookie settings, *status* turns to `true` if cookie has been validated.  
+GET /api/cookie/
+```json
+{
+    "cookie_enabled": true,
+    "status": true,
+    "validated": <timestamp>,
+    "validated_str": "timestamp"
+}
+```
+
+POST /api/cookie/  
+Send empty post request to validate cookie.
+```json
+{
+    "cookie_validated": true
+}
+```
+
+PUT /api/cookie/  
+Send put request containing the cookie as a string:
+```json
+{
+    "cookie": "your-cookie-as-string"
+}
+```
+Imports and validates cookie, returns on success:
+```json
+{
+    "cookie_import": "done",
+    "cookie_validated": true
+}
+```
+Or returns status code 400 on failure:
+```json
+{
+    "cookie_import": "fail",
+    "cookie_validated": false
+}
+```
--- a/tubearchivist/api/src/search_processor.py
+++ b/tubearchivist/api/src/search_processor.py
@@ -7,12 +7,16 @@ Functionality:
 import urllib.parse

 from home.src.download.thumbnails import ThumbManager
+from home.src.ta.config import AppConfig
 from home.src.ta.helper import date_praser


 class SearchProcess:
    """process search results"""

+    CONFIG = AppConfig().config
+    CACHE_DIR = CONFIG["application"]["cache_dir"]
+
    def __init__(self, response):
        self.response = response
        self.processed = False
@@ -42,6 +46,8 @@ class SearchProcess:
            processed = self._process_channel(result["_source"])
        if index == "ta_playlist":
            processed = self._process_playlist(result["_source"])
+        if index == "ta_download":
+            processed = self._process_download(result["_source"])

        return processed

@@ -71,13 +77,18 @@ class SearchProcess:
        vid_thumb_url = ThumbManager().vid_thumb_path(video_id)
        channel = self._process_channel(video_dict["channel"])

+        if "subtitles" in video_dict:
+            for idx, _ in enumerate(video_dict["subtitles"]):
+                url = video_dict["subtitles"][idx]["media_url"]
+                video_dict["subtitles"][idx]["media_url"] = f"/media/{url}"
+
        video_dict.update(
            {
                "channel": channel,
-                "media_url": media_url,
+                "media_url": f"/media/{media_url}",
                "vid_last_refresh": vid_last_refresh,
                "published": published,
-                "vid_thumb_url": vid_thumb_url,
+                "vid_thumb_url": f"{self.CACHE_DIR}/{vid_thumb_url}",
            }
        )

@@ -98,3 +109,17 @@ class SearchProcess:
        )

        return dict(sorted(playlist_dict.items()))
+
+    def _process_download(self, download_dict):
+        """run on single download item"""
+        video_id = download_dict["youtube_id"]
+        vid_thumb_url = ThumbManager().vid_thumb_path(video_id)
+        published = date_praser(download_dict["published"])
+
+        download_dict.update(
+            {
+                "vid_thumb_url": f"{self.CACHE_DIR}/{vid_thumb_url}",
+                "published": published,
+            }
+        )
+        return dict(sorted(download_dict.items()))
--- a/tubearchivist/api/src/task_processor.py
+++ b/tubearchivist/api/src/task_processor.py
@@ -0,0 +1,54 @@
+"""
+Functionality:
+- process tasks from API
+- validate
+- handover to celery
+"""
+
+from home.src.ta.ta_redis import RedisArchivist
+from home.tasks import download_pending, update_subscribed
+
+
+class TaskHandler:
+    """handle tasks from api"""
+
+    def __init__(self, data):
+        self.data = data
+
+    def run_task(self):
+        """map data and run"""
+        task_name = self.data["run"]
+        try:
+            to_run = self.exec_map(task_name)
+        except KeyError as err:
+            print(f"invalid task name {task_name}")
+            raise ValueError from err
+
+        response = to_run()
+        response.update({"task": task_name})
+        return response
+
+    def exec_map(self, task_name):
+        """map dict key and return function to execute"""
+        exec_map = {
+            "download_pending": self._download_pending,
+            "rescan_pending": self._rescan_pending,
+        }
+
+        return exec_map[task_name]
+
+    @staticmethod
+    def _rescan_pending():
+        """look for new items in subscribed channels"""
+        print("rescan subscribed channels")
+        update_subscribed.delay()
+        return {"success": True}
+
+    @staticmethod
+    def _download_pending():
+        """start the download queue"""
+        print("download pending")
+        running = download_pending.delay()
+        print("set task id: " + running.id)
+        RedisArchivist().set_message("dl_queue_id", running.id)
+        return {"success": True}
--- a/tubearchivist/api/urls.py
+++ b/tubearchivist/api/urls.py
@@ -2,13 +2,17 @@

 from api.views import (
    ChannelApiListView,
+    ChannelApiVideoView,
    ChannelApiView,
+    CookieView,
    DownloadApiListView,
    DownloadApiView,
    LoginApiView,
    PingView,
    PlaylistApiListView,
+    PlaylistApiVideoView,
    PlaylistApiView,
+    TaskApiView,
    VideoApiListView,
    VideoApiView,
    VideoProgressView,
@@ -50,15 +54,25 @@ urlpatterns = [
        name="api-channel",
    ),
    path(
-        "playlist/<slug:playlist_id>/",
-        PlaylistApiView.as_view(),
-        name="api-playlist",
+        "channel/<slug:channel_id>/video/",
+        ChannelApiVideoView.as_view(),
+        name="api-channel-video",
    ),
    path(
        "playlist/",
        PlaylistApiListView.as_view(),
        name="api-playlist-list",
    ),
+    path(
+        "playlist/<slug:playlist_id>/",
+        PlaylistApiView.as_view(),
+        name="api-playlist",
+    ),
+    path(
+        "playlist/<slug:playlist_id>/video/",
+        PlaylistApiVideoView.as_view(),
+        name="api-playlist-video",
+    ),
    path(
        "download/",
        DownloadApiListView.as_view(),
@@ -69,4 +83,14 @@ urlpatterns = [
        DownloadApiView.as_view(),
        name="api-download",
    ),
+    path(
+        "task/",
+        TaskApiView.as_view(),
+        name="api-task",
+    ),
+    path(
+        "cookie/",
+        CookieView.as_view(),
+        name="api-cookie",
+    ),
 ]
--- a/tubearchivist/api/views.py
+++ b/tubearchivist/api/views.py
@@ -1,12 +1,15 @@
 """all API views"""

 from api.src.search_processor import SearchProcess
-from home.src.download.thumbnails import ThumbManager
+from api.src.task_processor import TaskHandler
+from home.src.download.queue import PendingInteract
+from home.src.download.yt_dlp_base import CookieHandler
 from home.src.es.connect import ElasticWrap
+from home.src.index.generic import Pagination
 from home.src.index.video import SponsorBlock
 from home.src.ta.config import AppConfig
 from home.src.ta.helper import UrlListParser
-from home.src.ta.ta_redis import RedisArchivist
+from home.src.ta.ta_redis import RedisArchivist, RedisQueue
 from home.tasks import extrac_dl, subscribe_to
 from rest_framework.authentication import (
    SessionAuthentication,
@@ -25,12 +28,15 @@ class ApiBaseView(APIView):
    authentication_classes = [SessionAuthentication, TokenAuthentication]
    permission_classes = [IsAuthenticated]
    search_base = False
+    data = False

    def __init__(self):
        super().__init__()
        self.response = {"data": False, "config": AppConfig().config}
+        self.data = {"query": {"match_all": {}}}
        self.status_code = False
        self.context = False
+        self.pagination_handler = False

    def get_document(self, document_id):
        """get single document from es"""
@@ -44,35 +50,32 @@ class ApiBaseView(APIView):
            self.response["data"] = False
        self.status_code = status_code

-    def process_keys(self):
-        """process keys for frontend"""
-        all_keys = self.response["data"].keys()
-        if "media_url" in all_keys:
-            media_url = self.response["data"]["media_url"]
-            self.response["data"]["media_url"] = f"/media/{media_url}"
-        if "vid_thumb_url" in all_keys:
-            youtube_id = self.response["data"]["youtube_id"]
-            vid_thumb_url = ThumbManager().vid_thumb_path(youtube_id)
-            cache_dir = self.response["config"]["application"]["cache_dir"]
-            new_thumb = f"{cache_dir}/{vid_thumb_url}"
-            self.response["data"]["vid_thumb_url"] = new_thumb
-        if "subtitles" in all_keys:
-            all_subtitles = self.response["data"]["subtitles"]
-            for idx, _ in enumerate(all_subtitles):
-                url = self.response["data"]["subtitles"][idx]["media_url"]
-                new_url = f"/media/{url}"
-                self.response["data"]["subtitles"][idx]["media_url"] = new_url
+    def initiate_pagination(self, request):
+        """set initial pagination values"""
+        user_id = request.user.id
+        page_get = int(request.GET.get("page", 0))
+        self.pagination_handler = Pagination(page_get, user_id)
+        self.data.update(
+            {
+                "size": self.pagination_handler.pagination["page_size"],
+                "from": self.pagination_handler.pagination["page_from"],
+            }
+        )

-    def get_paginate(self):
-        """add pagination detail to response"""
-        self.response["paginate"] = False
-
-    def get_document_list(self, data):
+    def get_document_list(self, request):
        """get a list of results"""
        print(self.search_base)
-        response, status_code = ElasticWrap(self.search_base).get(data=data)
+        self.initiate_pagination(request)
+        es_handler = ElasticWrap(self.search_base)
+        response, status_code = es_handler.get(data=self.data)
        self.response["data"] = SearchProcess(response).process()
-        self.status_code = status_code
+        if self.response["data"]:
+            self.status_code = status_code
+        else:
+            self.status_code = 404
+
+        self.pagination_handler.validate(response["hits"]["total"]["value"])
+        self.response["paginate"] = self.pagination_handler.pagination


 class VideoApiView(ApiBaseView):
@@ -86,8 +89,6 @@ class VideoApiView(ApiBaseView):
        # pylint: disable=unused-argument
        """get request"""
        self.get_document(video_id)
-        if self.response.get("data"):
-            self.process_keys()
        return Response(self.response, status=self.status_code)


@@ -99,11 +100,9 @@ class VideoApiListView(ApiBaseView):
    search_base = "ta_video/_search/"

    def get(self, request):
-        # pylint: disable=unused-argument
        """get request"""
-        data = {"query": {"match_all": {}}}
-        self.get_document_list(data)
-        self.get_paginate()
+        self.data.update({"sort": [{"published": {"order": "desc"}}]})
+        self.get_document_list(request)

        return Response(self.response)

@@ -132,7 +131,7 @@ class VideoProgressView(ApiBaseView):
        position = request.data.get("position", 0)
        key = f"{request.user.id}:progress:{video_id}"
        message = {"position": position, "youtube_id": video_id}
-        RedisArchivist().set_message(key, message, expire=False)
+        RedisArchivist().set_message(key, message)
        self.response = request.data

        return Response(self.response)
@@ -218,11 +217,11 @@ class ChannelApiListView(ApiBaseView):
    search_base = "ta_channel/_search/"

    def get(self, request):
-        # pylint: disable=unused-argument
        """get request"""
-        data = {"query": {"match_all": {}}}
-        self.get_document_list(data)
-        self.get_paginate()
+        self.get_document_list(request)
+        self.data.update(
+            {"sort": [{"channel_name.keyword": {"order": "asc"}}]}
+        )

        return Response(self.response)

@@ -244,6 +243,44 @@ class ChannelApiListView(ApiBaseView):
        return Response(data)


+class ChannelApiVideoView(ApiBaseView):
+    """resolves to /api/channel/<channel-id>/video
+    GET: returns a list of videos of channel
+    """
+
+    search_base = "ta_video/_search/"
+
+    def get(self, request, channel_id):
+        """handle get request"""
+        self.data.update(
+            {
+                "query": {
+                    "term": {"channel.channel_id": {"value": channel_id}}
+                },
+                "sort": [{"published": {"order": "desc"}}],
+            }
+        )
+        self.get_document_list(request)
+
+        return Response(self.response, status=self.status_code)
+
+
+class PlaylistApiListView(ApiBaseView):
+    """resolves to /api/playlist/
+    GET: returns list of indexed playlists
+    """
+
+    search_base = "ta_playlist/_search/"
+
+    def get(self, request):
+        """handle get request"""
+        self.data.update(
+            {"sort": [{"playlist_name.keyword": {"order": "asc"}}]}
+        )
+        self.get_document_list(request)
+        return Response(self.response)
+
+
 class PlaylistApiView(ApiBaseView):
    """resolves to /api/playlist/<playlist_id>/
    GET: returns metadata dict of playlist
@@ -258,28 +295,33 @@ class PlaylistApiView(ApiBaseView):
        return Response(self.response, status=self.status_code)


-class PlaylistApiListView(ApiBaseView):
-    """resolves to /api/playlist/
-    GET: returns list of indexed playlists
+class PlaylistApiVideoView(ApiBaseView):
+    """resolves to /api/playlist/<playlist_id>/video
+    GET: returns list of videos in playlist
    """

-    search_base = "ta_playlist/_search/"
+    search_base = "ta_video/_search/"

-    def get(self, request):
-        # pylint: disable=unused-argument
+    def get(self, request, playlist_id):
        """handle get request"""
-        data = {"query": {"match_all": {}}}
-        self.get_document_list(data)
-        self.get_paginate()
-        return Response(self.response)
+        self.data["query"] = {
+            "term": {"playlist.keyword": {"value": playlist_id}}
+        }
+        self.data.update({"sort": [{"published": {"order": "desc"}}]})
+
+        self.get_document_list(request)
+        return Response(self.response, status=self.status_code)


 class DownloadApiView(ApiBaseView):
    """resolves to /api/download/<video_id>/
    GET: returns metadata dict of an item in the download queue
+    POST: update status of item to pending or ignore
+    DELETE: forget from download queue
    """

    search_base = "ta_download/_doc/"
+    valid_status = ["pending", "ignore"]

    def get(self, request, video_id):
        # pylint: disable=unused-argument
@@ -287,21 +329,53 @@ class DownloadApiView(ApiBaseView):
        self.get_document(video_id)
        return Response(self.response, status=self.status_code)

+    def post(self, request, video_id):
+        """post to video to change status"""
+        item_status = request.data["status"]
+        if item_status not in self.valid_status:
+            message = f"{video_id}: invalid status {item_status}"
+            print(message)
+            return Response({"message": message}, status=400)
+
+        print(f"{video_id}: change status to {item_status}")
+        PendingInteract(video_id=video_id, status=item_status).update_status()
+        RedisQueue().clear_item(video_id)
+
+        return Response(request.data)
+
+    @staticmethod
+    def delete(request, video_id):
+        # pylint: disable=unused-argument
+        """delete single video from queue"""
+        print(f"{video_id}: delete from queue")
+        PendingInteract(video_id=video_id).delete_item()
+
+        return Response({"success": True})
+

 class DownloadApiListView(ApiBaseView):
    """resolves to /api/download/
    GET: returns latest videos in the download queue
    POST: add a list of videos to download queue
+    DELETE: remove items based on query filter
    """

    search_base = "ta_download/_search/"
+    valid_filter = ["pending", "ignore"]

    def get(self, request):
-        # pylint: disable=unused-argument
        """get request"""
-        data = {"query": {"match_all": {}}}
-        self.get_document_list(data)
-        self.get_paginate()
+        query_filter = request.GET.get("filter", False)
+        self.data.update({"sort": [{"timestamp": {"order": "asc"}}]})
+        if query_filter:
+            if query_filter not in self.valid_filter:
+                message = f"invalid url query filder: {query_filter}"
+                print(message)
+                return Response({"message": message}, status=400)
+
+            self.data["query"] = {"term": {"status": {"value": query_filter}}}
+
+        self.get_document_list(request)
        return Response(self.response)

    @staticmethod
@@ -329,6 +403,20 @@ class DownloadApiListView(ApiBaseView):

        return Response(data)

+    def delete(self, request):
+        """delete download queue"""
+        query_filter = request.GET.get("filter", False)
+        if query_filter not in self.valid_filter:
+            message = f"invalid url query filter: {query_filter}"
+            print(message)
+            return Response({"message": message}, status=400)
+
+        message = f"delete queue by status: {query_filter}"
+        print(message)
+        PendingInteract(status=query_filter).delete_by_status()
+
+        return Response({"message": message})
+

 class PingView(ApiBaseView):
    """resolves to /api/ping/
@@ -360,3 +448,81 @@ class LoginApiView(ObtainAuthToken):
        print(f"returning token for user with id {user.pk}")

        return Response({"token": token.key, "user_id": user.pk})
+
+
+class TaskApiView(ApiBaseView):
+    """resolves to /api/task/
+    GET: check if ongoing background task
+    POST: start a new background task
+    """
+
+    @staticmethod
+    def get(request):
+        """handle get request"""
+        # pylint: disable=unused-argument
+        response = {"rescan": False, "downloading": False}
+        for key in response.keys():
+            response[key] = RedisArchivist().is_locked(key)
+
+        return Response(response)
+
+    def post(self, request):
+        """handle post request"""
+
+        data = request.data
+        print(data)
+        response = TaskHandler(data).run_task()
+
+        return Response(response)
+
+
+class CookieView(ApiBaseView):
+    """resolves to /api/cookie/
+    GET: check if cookie is enabled
+    POST: verify validity of cookie
+    PUT: import cookie
+    """
+
+    @staticmethod
+    def get(request):
+        """handle get request"""
+        # pylint: disable=unused-argument
+        config = AppConfig().config
+        valid = RedisArchivist().get_message("cookie:valid")
+        response = {"cookie_enabled": config["downloads"]["cookie_import"]}
+        response.update(valid)
+
+        return Response(response)
+
+    @staticmethod
+    def post(request):
+        """handle post request"""
+        # pylint: disable=unused-argument
+        config = AppConfig().config
+        validated = CookieHandler(config).validate()
+
+        return Response({"cookie_validated": validated})
+
+    @staticmethod
+    def put(request):
+        """handle put request"""
+        # pylint: disable=unused-argument
+        config = AppConfig().config
+        cookie = request.data.get("cookie")
+        if not cookie:
+            message = "missing cookie key in request data"
+            print(message)
+            return Response({"message": message}, status=400)
+
+        print(f"cookie preview:\n\n{cookie[:300]}")
+        handler = CookieHandler(config)
+        handler.set_cookie(cookie)
+        validated = handler.validate()
+        if not validated:
+            handler.revoke()
+            message = {"cookie_import": "fail", "cookie_validated": validated}
+            print(f"cookie: {message}")
+            return Response({"message": message}, status=400)
+
+        message = {"cookie_import": "done", "cookie_validated": validated}
+        return Response(message)
--- a/tubearchivist/config/settings.py
+++ b/tubearchivist/config/settings.py
@@ -146,7 +146,16 @@ LOGOUT_REDIRECT_URL = "/login/"

 # Cors needed for browser extension
 # background.js makes the request so HTTP_ORIGIN will be from extension
-CORS_ALLOWED_ORIGIN_REGEXES = [r"moz-extension://*", r"chrome-extension://*"]
+if environ.get("DISABLE_CORS"):
+    # disable cors
+    CORS_ORIGIN_ALLOW_ALL = True
+else:
+    CORS_ALLOWED_ORIGIN_REGEXES = [
+        r"moz-extension://*",
+        r"chrome-extension://*",
+    ]
+    CORS_ALLOWED_ORIGINS = ["http://localhost:3000"]
+

 CORS_ALLOW_HEADERS = list(default_headers) + [
    "mode",
@@ -154,4 +163,4 @@ CORS_ALLOW_HEADERS = list(default_headers) + [

 # TA application settings
 TA_UPSTREAM = "https://github.com/tubearchivist/tubearchivist"
-TA_VERSION = "v0.1.4"
+TA_VERSION = "v0.1.7"
--- a/tubearchivist/home/apps.py
+++ b/tubearchivist/home/apps.py
@@ -28,6 +28,7 @@ class StartupCheck:
        self.release_lock()
        index_check()
        self.sync_redis_state()
+        self.set_redis_conf()
        self.make_folders()
        self.set_has_run()

@@ -45,6 +46,10 @@ class StartupCheck:
        print("sync redis")
        self.config_handler.load_new_defaults()

+    def set_redis_conf(self):
+        """set conf values for redis"""
+        self.redis_con.conn.config_set("timeout", 3600)
+
    def make_folders(self):
        """make needed cache folders here so docker doesn't mess it up"""
        folders = [
--- a/tubearchivist/home/config.json
+++ b/tubearchivist/home/config.json
@@ -8,7 +8,8 @@
        "home": "grid",
        "channel": "list",
        "downloads": "list",
-        "playlist": "grid"
+        "playlist": "grid",
+        "grid_items": 3
    },
    "subscriptions": {
        "auto_search": false,
@@ -26,6 +27,7 @@
        "subtitle": false,
        "subtitle_source": false,
        "subtitle_index": false,
+        "cookie_import": false,
        "throttledratelimit": false,
        "integrate_ryd": false,
        "integrate_sponsorblock": false
--- a/tubearchivist/home/src/download/queue.py
+++ b/tubearchivist/home/src/download/queue.py
@@ -7,14 +7,15 @@ Functionality:
 import json
 from datetime import datetime

-import yt_dlp
 from home.src.download.subscriptions import (
    ChannelSubscription,
    PlaylistSubscription,
 )
 from home.src.download.thumbnails import ThumbManager
+from home.src.download.yt_dlp_base import YtWrap
 from home.src.es.connect import ElasticWrap, IndexPaginate
 from home.src.index.playlist import YoutubePlaylist
+from home.src.ta.config import AppConfig
 from home.src.ta.helper import DurationConverter
 from home.src.ta.ta_redis import RedisArchivist

@@ -101,7 +102,7 @@ class PendingInteract:
    def delete_item(self):
        """delete single item from pending"""
        path = f"ta_download/_doc/{self.video_id}"
-        _, _ = ElasticWrap(path).delete()
+        _, _ = ElasticWrap(path).delete(refresh=True)

    def delete_by_status(self):
        """delete all matching item by status"""
@@ -119,8 +120,19 @@ class PendingInteract:
 class PendingList(PendingIndex):
    """manage the pending videos list"""

+    yt_obs = {
+        "default_search": "ytsearch",
+        "quiet": True,
+        "check_formats": "selected",
+        "noplaylist": True,
+        "writethumbnail": True,
+        "simulate": True,
+        "socket_timeout": 3,
+    }
+
    def __init__(self, youtube_ids=False):
        super().__init__()
+        self.config = AppConfig().config
        self.youtube_ids = youtube_ids
        self.to_skip = False
        self.missing_videos = False
@@ -138,7 +150,7 @@ class PendingList(PendingIndex):
                "title": "Adding to download queue.",
                "message": "Extracting lists",
            }
-            RedisArchivist().set_message("message:add", mess_dict)
+            RedisArchivist().set_message("message:add", mess_dict, expire=True)
            self._process_entry(entry)

    def _process_entry(self, entry):
@@ -160,6 +172,8 @@ class PendingList(PendingIndex):
        """add video to list"""
        if url not in self.missing_videos and url not in self.to_skip:
            self.missing_videos.append(url)
+        else:
+            print(f"{url}: skipped adding already indexed video to download.")

    def _parse_channel(self, url):
        """add all videos of channel to list"""
@@ -199,10 +213,11 @@ class PendingList(PendingIndex):
            thumb_handler.download_vid(thumb_needed)
            self._notify_add(idx)

-        # add last newline
-        bulk_list.append("\n")
-        query_str = "\n".join(bulk_list)
-        _, _ = ElasticWrap("_bulk").post(query_str, ndjson=True)
+        if bulk_list:
+            # add last newline
+            bulk_list.append("\n")
+            query_str = "\n".join(bulk_list)
+            _, _ = ElasticWrap("_bulk").post(query_str, ndjson=True)

    def _notify_add(self, idx):
        """send notification for adding videos to download queue"""
@@ -214,27 +229,23 @@ class PendingList(PendingIndex):
            "message": "Progress: " + progress,
        }
        if idx + 1 == len(self.missing_videos):
-            RedisArchivist().set_message("message:add", mess_dict, expire=4)
+            expire = 4
        else:
-            RedisArchivist().set_message("message:add", mess_dict)
+            expire = True

+        RedisArchivist().set_message("message:add", mess_dict, expire=expire)
        if idx + 1 % 25 == 0:
            print("adding to queue progress: " + progress)

    def get_youtube_details(self, youtube_id):
        """get details from youtubedl for single pending video"""
-        obs = {
-            "default_search": "ytsearch",
-            "quiet": True,
-            "check_formats": "selected",
-            "noplaylist": True,
-            "writethumbnail": True,
-            "simulate": True,
-        }
-        try:
-            vid = yt_dlp.YoutubeDL(obs).extract_info(youtube_id)
-        except yt_dlp.utils.DownloadError:
-            print("failed to extract info for: " + youtube_id)
+        vid = YtWrap(self.yt_obs, self.config).extract(youtube_id)
+        if not vid:
+            return False
+
+        if vid.get("id") != youtube_id:
+            # skip premium videos with different id
+            print(f"{youtube_id}: skipping premium video, id not matching")
            return False
        # stop if video is streaming live now
        if vid["is_live"]:
@@ -259,9 +270,12 @@ class PendingList(PendingIndex):
            "vid_thumb_url": vid["thumbnail"],
            "title": vid["title"],
            "channel_id": vid["channel_id"],
-            "channel_indexed": vid["channel_id"] in self.all_channels,
            "duration": duration_str,
            "published": published,
            "timestamp": int(datetime.now().strftime("%s")),
        }
+        if self.all_channels:
+            youtube_details.update(
+                {"channel_indexed": vid["channel_id"] in self.all_channels}
+            )
        return youtube_details
--- a/tubearchivist/home/src/download/subscriptions.py
+++ b/tubearchivist/home/src/download/subscriptions.py
@@ -4,8 +4,8 @@ Functionality:
 - handle playlist subscriptions
 """

-import yt_dlp
 from home.src.download import queue  # partial import
+from home.src.download.yt_dlp_base import YtWrap
 from home.src.es.connect import IndexPaginate
 from home.src.index.channel import YoutubeChannel
 from home.src.index.playlist import YoutubePlaylist
@@ -17,10 +17,7 @@ class ChannelSubscription:
    """manage the list of channels subscribed"""

    def __init__(self):
-        config = AppConfig().config
-        self.es_url = config["application"]["es_url"]
-        self.es_auth = config["application"]["es_auth"]
-        self.channel_size = config["subscriptions"]["channel_size"]
+        self.config = AppConfig().config

    @staticmethod
    def get_channels(subscribed_only=True):
@@ -39,23 +36,19 @@ class ChannelSubscription:

    def get_last_youtube_videos(self, channel_id, limit=True):
        """get a list of last videos from channel"""
-        url = f"https://www.youtube.com/channel/{channel_id}/videos"
        obs = {
-            "default_search": "ytsearch",
-            "quiet": True,
            "skip_download": True,
            "extract_flat": True,
        }
        if limit:
-            obs["playlistend"] = self.channel_size
+            obs["playlistend"] = self.config["subscriptions"]["channel_size"]

-        try:
-            chan = yt_dlp.YoutubeDL(obs).extract_info(url, download=False)
-        except yt_dlp.utils.DownloadError:
-            print(f"{channel_id}: failed to extract videos, skipping.")
+        url = f"https://www.youtube.com/channel/{channel_id}/videos"
+        channel = YtWrap(obs, self.config).extract(url)
+        if not channel:
            return False

-        last_videos = [(i["id"], i["title"]) for i in chan["entries"]]
+        last_videos = [(i["id"], i["title"]) for i in channel["entries"]]
        return last_videos

    def find_missing(self):
@@ -83,11 +76,13 @@ class ChannelSubscription:
                "message": f"Progress: {idx + 1}/{len(all_channels)}",
            }
            if idx + 1 == len(all_channels):
-                RedisArchivist().set_message(
-                    "message:rescan", message=message, expire=4
-                )
+                expire = 4
            else:
-                RedisArchivist().set_message("message:rescan", message=message)
+                expire = True
+
+            RedisArchivist().set_message(
+                "message:rescan", message=message, expire=expire
+            )

        return missing_videos

@@ -159,7 +154,7 @@ class PlaylistSubscription:
                "message": f"Processing {idx + 1} of {len(new_playlists)}",
            }
            RedisArchivist().set_message(
-                "message:subplaylist", message=message
+                "message:subplaylist", message=message, expire=True
            )

        return new_thumbs
@@ -168,7 +163,7 @@ class PlaylistSubscription:
    def channel_validate(channel_id):
        """make sure channel of playlist is there"""
        channel = YoutubeChannel(channel_id)
-        channel.build_json()
+        channel.build_json(upload=True)

    @staticmethod
    def change_subscribe(playlist_id, subscribe_status):
@@ -213,7 +208,9 @@ class PlaylistSubscription:
                "title": "Scanning playlists: Looking for new videos.",
                "message": f"Progress: {idx + 1}/{len(all_playlists)}",
            }
-            RedisArchivist().set_message("message:rescan", message=message)
+            RedisArchivist().set_message(
+                "message:rescan", message=message, expire=True
+            )

            for video in all_missing:
                youtube_id = video["youtube_id"]
--- a/tubearchivist/home/src/download/thumbnails.py
+++ b/tubearchivist/home/src/download/thumbnails.py
@@ -17,7 +17,9 @@ from home.src.ta.config import AppConfig
 from home.src.ta.helper import ignore_filelist
 from home.src.ta.ta_redis import RedisArchivist
 from mutagen.mp4 import MP4, MP4Cover
-from PIL import Image, ImageFilter
+from PIL import Image, ImageFile, ImageFilter
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True


 class ThumbManager:
@@ -191,11 +193,13 @@ class ThumbManager:
                    "message": "Downloading Thumbnails, Progress: " + progress,
                }
                if idx + 1 == len(missing_thumbs):
-                    RedisArchivist().set_message(
-                        "message:add", mess_dict, expire=4
-                    )
+                    expire = 4
                else:
-                    RedisArchivist().set_message("message:add", mess_dict)
+                    expire = True
+
+                RedisArchivist().set_message(
+                    "message:add", mess_dict, expire=expire
+                )

            if idx + 1 % 25 == 0:
                print("thumbnail progress: " + progress)
@@ -224,7 +228,8 @@ class ThumbManager:
                "title": "Processing Channels",
                "message": "Downloading Channel Art.",
            }
-            RedisArchivist().set_message("message:download", mess_dict)
+            key = "message:download"
+            RedisArchivist().set_message(key, mess_dict, expire=True)

    def download_playlist(self, missing_playlists):
        """download needed artwork for playlists"""
@@ -241,7 +246,8 @@ class ThumbManager:
                "title": "Processing Playlists",
                "message": "Downloading Playlist Art.",
            }
-            RedisArchivist().set_message("message:download", mess_dict)
+            key = "message:download"
+            RedisArchivist().set_message(key, mess_dict, expire=True)

    def get_base64_blur(self, youtube_id):
        """return base64 encoded placeholder"""
@@ -296,6 +302,7 @@ class ThumbManager:
    def get_thumb_list(self):
        """get list of mediafiles and matching thumbnails"""
        pending = queue.PendingList()
+        pending.get_download()
        pending.get_indexed()

        video_list = []
--- a/tubearchivist/home/src/download/yt_dlp_base.py
+++ b/tubearchivist/home/src/download/yt_dlp_base.py
@@ -0,0 +1,151 @@
+"""
+functionality:
+- base class to make all calls to yt-dlp
+- handle yt-dlp errors
+"""
+
+import os
+from datetime import datetime
+from http import cookiejar
+from io import StringIO
+
+import yt_dlp
+from home.src.ta.ta_redis import RedisArchivist
+
+
+class YtWrap:
+    """wrap calls to yt"""
+
+    OBS_BASE = {
+        "default_search": "ytsearch",
+        "quiet": True,
+        "check_formats": "selected",
+        "socket_timeout": 2,
+    }
+
+    def __init__(self, obs_request, config=False):
+        self.obs_request = obs_request
+        self.config = config
+        self.build_obs()
+
+    def build_obs(self):
+        """build yt-dlp obs"""
+        self.obs = self.OBS_BASE.copy()
+        self.obs.update(self.obs_request)
+        if self.config:
+            self.add_cookie()
+
+    def add_cookie(self):
+        """add cookie if enabled"""
+        if self.config["downloads"]["cookie_import"]:
+            cookie_io = CookieHandler(self.config).get()
+            self.obs["cookiefile"] = cookie_io
+
+    def download(self, url):
+        """make download request"""
+        with yt_dlp.YoutubeDL(self.obs) as ydl:
+            try:
+                ydl.download([url])
+            except yt_dlp.utils.DownloadError:
+                print(f"{url}: failed to download.")
+                return False
+
+        return True
+
+    def extract(self, url):
+        """make extract request"""
+        try:
+            response = yt_dlp.YoutubeDL(self.obs).extract_info(url)
+        except cookiejar.LoadError:
+            print("cookie file is invalid")
+            return False
+        except (yt_dlp.utils.ExtractorError, yt_dlp.utils.DownloadError):
+            print(f"{url}: failed to get info from youtube")
+            return False
+
+        return response
+
+
+class CookieHandler:
+    """handle youtube cookie for yt-dlp"""
+
+    def __init__(self, config):
+        self.cookie_io = False
+        self.config = config
+
+    def get(self):
+        """get cookie io stream"""
+        cookie = RedisArchivist().get_message("cookie")
+        self.cookie_io = StringIO(cookie)
+        return self.cookie_io
+
+    def import_cookie(self):
+        """import cookie from file"""
+        cache_path = self.config["application"]["cache_dir"]
+        import_path = os.path.join(cache_path, "import", "cookies.google.txt")
+        with open(import_path, encoding="utf-8") as cookie_file:
+            cookie = cookie_file.read()
+
+        self.set_cookie(cookie)
+
+        os.remove(import_path)
+        print("cookie: import successful")
+
+    def set_cookie(self, cookie):
+        """set cookie str and activate in cofig"""
+        RedisArchivist().set_message("cookie", cookie)
+        path = ".downloads.cookie_import"
+        RedisArchivist().set_message("config", True, path=path)
+        self.config["downloads"]["cookie_import"] = True
+        print("cookie: activated and stored in Redis")
+
+    @staticmethod
+    def revoke():
+        """revoke cookie"""
+        RedisArchivist().del_message("cookie")
+        RedisArchivist().del_message("cookie:valid")
+        RedisArchivist().set_message(
+            "config", False, path=".downloads.cookie_import"
+        )
+        print("cookie: revoked")
+
+    def validate(self):
+        """validate cookie using the liked videos playlist"""
+        print("validating cookie")
+        obs_request = {
+            "skip_download": True,
+            "extract_flat": True,
+        }
+        validator = YtWrap(obs_request, self.config)
+        response = bool(validator.extract("LL"))
+        self.store_validation(response)
+
+        # update in redis to avoid expiring
+        modified = validator.obs["cookiefile"].getvalue()
+        if modified:
+            RedisArchivist().set_message("cookie", modified)
+
+        if not response:
+            mess_dict = {
+                "status": "message:download",
+                "level": "error",
+                "title": "Cookie validation failed, exiting...",
+                "message": "",
+            }
+            RedisArchivist().set_message(
+                "message:download", mess_dict, expire=4
+            )
+            print("cookie validation failed, exiting...")
+
+        return response
+
+    @staticmethod
+    def store_validation(response):
+        """remember last validation"""
+        now = datetime.now()
+        message = {
+            "status": response,
+            "validated": int(now.strftime("%s")),
+            "validated_str": now.strftime("%Y-%m-%d %H:%M"),
+        }
+        RedisArchivist().set_message("cookie:valid", message)
--- a/tubearchivist/home/src/download/yt_dlp_handler.py
+++ b/tubearchivist/home/src/download/yt_dlp_handler.py
@@ -9,11 +9,10 @@ functionality:
 import os
 import shutil
 from datetime import datetime
-from time import sleep

-import yt_dlp
 from home.src.download.queue import PendingList
 from home.src.download.subscriptions import PlaylistSubscription
+from home.src.download.yt_dlp_base import CookieHandler, YtWrap
 from home.src.es.connect import ElasticWrap, IndexPaginate
 from home.src.index.channel import YoutubeChannel
 from home.src.index.playlist import YoutubePlaylist
@@ -126,18 +125,19 @@ class DownloadPostProcess:
            + f"{id_c + 1}/{len(self.download.channels)}"
        )
        message = f"Progress: {id_p + 1}/{len(all_channel_playlist)}"
+        key = "message:download"
        mess_dict = {
-            "status": "message:download",
+            "status": key,
            "level": "info",
            "title": title,
            "message": message,
        }
        if id_p + 1 == len(all_channel_playlist):
-            RedisArchivist().set_message(
-                "message:download", mess_dict, expire=4
-            )
+            expire = 4
        else:
-            RedisArchivist().set_message("message:download", mess_dict)
+            expire = True
+
+        RedisArchivist().set_message(key, mess_dict, expire=expire)


 class VideoDownloader:
@@ -146,6 +146,8 @@ class VideoDownloader:
    if not initiated with list, take from queue
    """

+    MSG = "message:download"
+
    def __init__(self, youtube_id_list=False):
        self.obs = False
        self.video_overwrites = False
@@ -156,10 +158,7 @@ class VideoDownloader:

    def run_queue(self):
        """setup download queue in redis loop until no more items"""
-        pending = PendingList()
-        pending.get_download()
-        pending.get_channels()
-        self.video_overwrites = pending.video_overwrites
+        self._setup_queue()

        queue = RedisQueue()

@@ -172,47 +171,57 @@ class VideoDownloader:
            if not youtube_id:
                break

-            try:
-                self._dl_single_vid(youtube_id)
-            except yt_dlp.utils.DownloadError:
-                print("failed to download " + youtube_id)
+            success = self._dl_single_vid(youtube_id)
+            if not success:
                continue
+
            vid_dict = index_new_video(
                youtube_id, video_overwrites=self.video_overwrites
            )
            self.channels.add(vid_dict["channel"]["channel_id"])
            mess_dict = {
-                "status": "message:download",
+                "status": self.MSG,
                "level": "info",
                "title": "Moving....",
                "message": "Moving downloaded file to storage folder",
            }
-            RedisArchivist().set_message("message:download", mess_dict, False)
+            RedisArchivist().set_message(self.MSG, mess_dict)

            self.move_to_archive(vid_dict)
            mess_dict = {
-                "status": "message:download",
+                "status": self.MSG,
                "level": "info",
                "title": "Completed",
                "message": "",
            }
-            RedisArchivist().set_message("message:download", mess_dict, 10)
+            RedisArchivist().set_message(self.MSG, mess_dict, expire=10)
            self._delete_from_pending(youtube_id)

        # post processing
        self._add_subscribed_channels()
        DownloadPostProcess(self).run()

-    @staticmethod
-    def add_pending():
+    def _setup_queue(self):
+        """setup required and validate"""
+        if self.config["downloads"]["cookie_import"]:
+            valid = CookieHandler(self.config).validate()
+            if not valid:
+                return
+
+        pending = PendingList()
+        pending.get_download()
+        pending.get_channels()
+        self.video_overwrites = pending.video_overwrites
+
+    def add_pending(self):
        """add pending videos to download queue"""
        mess_dict = {
-            "status": "message:download",
+            "status": self.MSG,
            "level": "info",
            "title": "Looking for videos to download",
            "message": "Scanning your download queue.",
        }
-        RedisArchivist().set_message("message:download", mess_dict)
+        RedisArchivist().set_message(self.MSG, mess_dict, expire=True)
        pending = PendingList()
        pending.get_download()
        to_add = [i["youtube_id"] for i in pending.all_pending]
@@ -220,18 +229,17 @@ class VideoDownloader:
            # there is nothing pending
            print("download queue is empty")
            mess_dict = {
-                "status": "message:download",
+                "status": self.MSG,
                "level": "error",
                "title": "Download queue is empty",
                "message": "Add some videos to the queue first.",
            }
-            RedisArchivist().set_message("message:download", mess_dict)
+            RedisArchivist().set_message(self.MSG, mess_dict, expire=True)
            return

        RedisQueue().add_list(to_add)

-    @staticmethod
-    def _progress_hook(response):
+    def _progress_hook(self, response):
        """process the progress_hooks from yt_dlp"""
        # title
        path = os.path.split(response["filename"])[-1][12:]
@@ -248,12 +256,12 @@ class VideoDownloader:
        except KeyError:
            message = "processing"
        mess_dict = {
-            "status": "message:download",
+            "status": self.MSG,
            "level": "info",
            "title": title,
            "message": message,
        }
-        RedisArchivist().set_message("message:download", mess_dict)
+        RedisArchivist().set_message(self.MSG, mess_dict, expire=True)

    def _build_obs(self):
        """collection to build all obs passed to yt-dlp"""
@@ -280,6 +288,7 @@ class VideoDownloader:
            "writethumbnail": False,
            "noplaylist": True,
            "check_formats": "selected",
+            "socket_timeout": 3,
        }

    def _build_obs_user(self):
@@ -307,6 +316,17 @@ class VideoDownloader:
                    "add_metadata": True,
                }
            )
+            postprocessors.append(
+                {
+                    "key": "MetadataFromField",
+                    "formats": [
+                        "%(title)s:%(meta_title)s",
+                        "%(uploader)s:%(meta_artist)s",
+                        ":(?P<album>)",
+                    ],
+                    "when": "pre_process",
+                }
+            )

        if self.config["downloads"]["add_thumbnail"]:
            postprocessors.append(
@@ -342,13 +362,7 @@ class VideoDownloader:
            if youtube_id in file_name:
                obs["outtmpl"] = os.path.join(dl_cache, file_name)

-        with yt_dlp.YoutubeDL(obs) as ydl:
-            try:
-                ydl.download([youtube_id])
-            except yt_dlp.utils.DownloadError:
-                print("retry failed download: " + youtube_id)
-                sleep(10)
-                ydl.download([youtube_id])
+        success = YtWrap(obs, self.config).download(youtube_id)

        if self.obs["writethumbnail"]:
            # webp files don't get cleaned up automatically
@@ -358,6 +372,8 @@ class VideoDownloader:
                file_path = os.path.join(dl_cache, file_name)
                os.remove(file_path)

+        return success
+
    def move_to_archive(self, vid_dict):
        """move downloaded video from cache to archive"""
        videos = self.config["application"]["videos"]
--- a/tubearchivist/home/src/es/connect.py
+++ b/tubearchivist/home/src/es/connect.py
@@ -75,8 +75,10 @@ class ElasticWrap:

        return response.json(), response.status_code

-    def delete(self, data=False):
+    def delete(self, data=False, refresh=False):
        """delete document from es"""
+        if refresh:
+            self.url = f"{self.url}/?refresh=true"
        if data:
            response = requests.delete(self.url, json=data, auth=self.auth)
        else:
--- a/tubearchivist/home/src/frontend/api_calls.py
+++ b/tubearchivist/home/src/frontend/api_calls.py
@@ -19,7 +19,6 @@ from home.src.ta.ta_redis import RedisArchivist, RedisQueue
 from home.tasks import (
    download_pending,
    download_single,
-    extrac_dl,
    index_channel_playlists,
    kill_dl,
    re_sync_thumbs,
@@ -55,6 +54,7 @@ class PostData:
            "watched": self._watched,
            "un_watched": self._un_watched,
            "change_view": self._change_view,
+            "change_grid": self._change_grid,
            "rescan_pending": self._rescan_pending,
            "ignore": self._ignore,
            "dl_pending": self._dl_pending,
@@ -98,7 +98,18 @@ class PostData:
        origin, new_view = self.exec_val.split(":")
        key = f"{self.current_user}:view:{origin}"
        print(f"change view: {key} to {new_view}")
-        RedisArchivist().set_message(key, {"status": new_view}, expire=False)
+        RedisArchivist().set_message(key, {"status": new_view})
+        return {"success": True}
+
+    def _change_grid(self):
+        """process change items in grid"""
+        grid_items = int(self.exec_val)
+        grid_items = max(grid_items, 3)
+        grid_items = min(grid_items, 7)
+
+        key = f"{self.current_user}:grid_items"
+        print(f"change grid items: {grid_items}")
+        RedisArchivist().set_message(key, {"status": grid_items})
        return {"success": True}

    @staticmethod
@@ -111,7 +122,7 @@ class PostData:
    def _ignore(self):
        """ignore from download queue"""
        video_id = self.exec_val
-        print(f"ignore video {video_id}")
+        print(f"{video_id}: ignore video from download queue")
        PendingInteract(video_id=video_id, status="ignore").update_status()
        # also clear from redis queue
        RedisQueue().clear_item(video_id)
@@ -123,8 +134,8 @@ class PostData:
        print("download pending")
        running = download_pending.delay()
        task_id = running.id
-        print("set task id: " + task_id)
-        RedisArchivist().set_message("dl_queue_id", task_id, expire=False)
+        print(f"{task_id}: set task id")
+        RedisArchivist().set_message("dl_queue_id", task_id)
        return {"success": True}

    def _queue_handler(self):
@@ -146,7 +157,7 @@ class PostData:
    def _unsubscribe(self):
        """unsubscribe from channels or playlists"""
        id_unsub = self.exec_val
-        print("unsubscribe from " + id_unsub)
+        print(f"{id_unsub}: unsubscribe")
        to_unsub_list = UrlListParser(id_unsub).process_list()
        for to_unsub in to_unsub_list:
            unsub_type = to_unsub["type"]
@@ -167,7 +178,7 @@ class PostData:
    def _subscribe(self):
        """subscribe to channel or playlist, called from js buttons"""
        id_sub = self.exec_val
-        print("subscribe to " + id_sub)
+        print(f"{id_sub}: subscribe")
        subscribe_to.delay(id_sub)
        return {"success": True}

@@ -176,11 +187,11 @@ class PostData:
        sort_order = {"status": self.exec_val}
        if self.exec_val in ["asc", "desc"]:
            RedisArchivist().set_message(
-                f"{self.current_user}:sort_order", sort_order, expire=False
+                f"{self.current_user}:sort_order", sort_order
            )
        else:
            RedisArchivist().set_message(
-                f"{self.current_user}:sort_by", sort_order, expire=False
+                f"{self.current_user}:sort_by", sort_order
            )
        return {"success": True}

@@ -189,7 +200,7 @@ class PostData:
        key = f"{self.current_user}:hide_watched"
        message = {"status": bool(int(self.exec_val))}
        print(f"toggle {key}: {message}")
-        RedisArchivist().set_message(key, message, expire=False)
+        RedisArchivist().set_message(key, message)
        return {"success": True}

    def _show_subed_only(self):
@@ -197,17 +208,17 @@ class PostData:
        key = f"{self.current_user}:show_subed_only"
        message = {"status": bool(int(self.exec_val))}
        print(f"toggle {key}: {message}")
-        RedisArchivist().set_message(key, message, expire=False)
+        RedisArchivist().set_message(key, message)
        return {"success": True}

    def _dlnow(self):
        """start downloading single vid now"""
        youtube_id = self.exec_val
-        print("downloading: " + youtube_id)
+        print(f"{youtube_id}: downloading now")
        running = download_single.delay(youtube_id=youtube_id)
        task_id = running.id
        print("set task id: " + task_id)
-        RedisArchivist().set_message("dl_queue_id", task_id, expire=False)
+        RedisArchivist().set_message("dl_queue_id", task_id)
        return {"success": True}

    def _show_ignored_only(self):
@@ -216,23 +227,21 @@ class PostData:
        key = f"{self.current_user}:show_ignored_only"
        value = {"status": show_value}
        print(f"Filter download view ignored only: {show_value}")
-        RedisArchivist().set_message(key, value, expire=False)
+        RedisArchivist().set_message(key, value)
        return {"success": True}

    def _forget_ignore(self):
        """delete from ta_download index"""
        video_id = self.exec_val
-        print(f"forgetting from download index: {video_id}")
+        print(f"{video_id}: forget from download")
        PendingInteract(video_id=video_id).delete_item()
        return {"success": True}

    def _add_single(self):
        """add single youtube_id to download queue"""
        video_id = self.exec_val
-        print(f"add vid to dl queue: {video_id}")
-        PendingInteract(video_id=video_id).delete_item()
-        video_ids = UrlListParser(video_id).process_list()
-        extrac_dl.delay(video_ids)
+        print(f"{video_id}: add single vid to download queue")
+        PendingInteract(video_id=video_id, status="pending").update_status()
        return {"success": True}

    def _delete_queue(self):
--- a/tubearchivist/home/src/frontend/forms.py
+++ b/tubearchivist/home/src/frontend/forms.py
@@ -86,6 +86,12 @@ class ApplicationSettingsForm(forms.Form):
        ("1", "enable subtitle index"),
    ]

+    COOKIE_IMPORT_CHOICES = [
+        ("", "-- change cookie settings"),
+        ("0", "disable cookie"),
+        ("1", "enable cookie"),
+    ]
+
    subscriptions_channel_size = forms.IntegerField(required=False)
    downloads_limit_count = forms.IntegerField(required=False)
    downloads_limit_speed = forms.IntegerField(required=False)
@@ -106,6 +112,9 @@ class ApplicationSettingsForm(forms.Form):
    downloads_subtitle_index = forms.ChoiceField(
        widget=forms.Select, choices=SUBTITLE_INDEX_CHOICES, required=False
    )
+    downloads_cookie_import = forms.ChoiceField(
+        widget=forms.Select, choices=COOKIE_IMPORT_CHOICES, required=False
+    )
    downloads_integrate_ryd = forms.ChoiceField(
        widget=forms.Select, choices=RYD_CHOICES, required=False
    )
--- a/tubearchivist/home/src/index/channel.py
+++ b/tubearchivist/home/src/index/channel.py
@@ -10,10 +10,10 @@ import re
 from datetime import datetime

 import requests
-import yt_dlp
 from bs4 import BeautifulSoup
 from home.src.download import queue  # partial import
 from home.src.download.thumbnails import ThumbManager
+from home.src.download.yt_dlp_base import YtWrap
 from home.src.es.connect import ElasticWrap, IndexPaginate
 from home.src.index.generic import YouTubeItem
 from home.src.index.playlist import YoutubePlaylist
@@ -153,6 +153,7 @@ class YoutubeChannel(YouTubeItem):
    es_path = False
    index_name = "ta_channel"
    yt_base = "https://www.youtube.com/channel/"
+    msg = "message:playlistscan"

    def __init__(self, youtube_id):
        super().__init__(youtube_id)
@@ -252,12 +253,12 @@ class YoutubeChannel(YouTubeItem):
        self.get_from_es()
        channel_name = self.json_data["channel_name"]
        mess_dict = {
-            "status": "message:playlistscan",
+            "status": self.msg,
            "level": "info",
            "title": "Looking for playlists",
            "message": f"{channel_name}: Scanning channel in progress",
        }
-        RedisArchivist().set_message("message:playlistscan", mess_dict)
+        RedisArchivist().set_message(self.msg, mess_dict, expire=True)
        self.get_all_playlists()
        if not self.all_playlists:
            print(f"{self.youtube_id}: no playlists found.")
@@ -272,12 +273,12 @@ class YoutubeChannel(YouTubeItem):
        """send notification"""
        channel_name = self.json_data["channel_name"]
        mess_dict = {
-            "status": "message:playlistscan",
+            "status": self.msg,
            "level": "info",
            "title": f"{channel_name}: Scanning channel for playlists",
            "message": f"Progress: {idx + 1}/{len(self.all_playlists)}",
        }
-        RedisArchivist().set_message("message:playlistscan", mess_dict)
+        RedisArchivist().set_message(self.msg, mess_dict, expire=True)
        print("add playlist: " + playlist[1])

    @staticmethod
@@ -314,12 +315,8 @@ class YoutubeChannel(YouTubeItem):
            f"https://www.youtube.com/channel/{self.youtube_id}"
            + "/playlists?view=1&sort=dd&shelf_id=0"
        )
-        obs = {
-            "quiet": True,
-            "skip_download": True,
-            "extract_flat": True,
-        }
-        playlists = yt_dlp.YoutubeDL(obs).extract_info(url)
+        obs = {"skip_download": True, "extract_flat": True}
+        playlists = YtWrap(obs, self.config).extract(url)
        all_entries = [(i["id"], i["title"]) for i in playlists["entries"]]
        self.all_playlists = all_entries

--- a/tubearchivist/home/src/index/filesystem.py
+++ b/tubearchivist/home/src/index/filesystem.py
@@ -310,4 +310,4 @@ def reindex_old_documents():
    handler = Reindex()
    handler.check_outdated()
    handler.reindex()
-    RedisArchivist().set_message("last_reindex", handler.now, expire=False)
+    RedisArchivist().set_message("last_reindex", handler.now)
--- a/tubearchivist/home/src/index/generic.py
+++ b/tubearchivist/home/src/index/generic.py
@@ -5,7 +5,7 @@ functionality:

 import math

-import yt_dlp
+from home.src.download.yt_dlp_base import YtWrap
 from home.src.es.connect import ElasticWrap
 from home.src.ta.config import AppConfig
 from home.src.ta.ta_redis import RedisArchivist
@@ -18,38 +18,22 @@ class YouTubeItem:
    index_name = False
    yt_base = False
    yt_obs = {
-        "quiet": True,
-        "default_search": "ytsearch",
        "skip_download": True,
-        "check_formats": "selected",
        "noplaylist": True,
    }

    def __init__(self, youtube_id):
        self.youtube_id = youtube_id
-        self.config = False
-        self.app_conf = False
-        self.youtube_meta = False
-        self.json_data = False
-        self._get_conf()
-
-    def _get_conf(self):
-        """read user conf"""
        self.config = AppConfig().config
        self.app_conf = self.config["application"]
+        self.youtube_meta = False
+        self.json_data = False

    def get_from_youtube(self):
        """use yt-dlp to get meta data from youtube"""
        print(f"{self.youtube_id}: get metadata from youtube")
-        try:
-            yt_item = yt_dlp.YoutubeDL(self.yt_obs)
-            response = yt_item.extract_info(self.yt_base + self.youtube_id)
-        except (
-            yt_dlp.utils.ExtractorError,
-            yt_dlp.utils.DownloadError,
-        ):
-            print(f"{self.youtube_id}: failed to get info from youtube")
-            response = False
+        url = self.yt_base + self.youtube_id
+        response = YtWrap(self.yt_obs, self.config).extract(url)

        self.youtube_meta = response

@@ -81,7 +65,7 @@ class YouTubeItem:
    def del_in_es(self):
        """delete item from elastic search"""
        print(f"{self.youtube_id}: delete from es")
-        _, _ = ElasticWrap(self.es_path).delete()
+        _, _ = ElasticWrap(self.es_path).delete(refresh=True)


 class Pagination:
@@ -147,3 +131,4 @@ class Pagination:
        ]

        self.pagination["next_pages"] = next_pages
+        self.pagination["total_hits"] = total_hits
--- a/tubearchivist/home/src/index/playlist.py
+++ b/tubearchivist/home/src/index/playlist.py
@@ -18,12 +18,7 @@ class YoutubePlaylist(YouTubeItem):

    es_path = False
    index_name = "ta_playlist"
-    yt_obs = {
-        "default_search": "ytsearch",
-        "quiet": True,
-        "skip_download": True,
-        "extract_flat": True,
-    }
+    yt_obs = {"extract_flat": True}
    yt_base = "https://www.youtube.com/playlist?list="

    def __init__(self, youtube_id):
--- a/tubearchivist/home/src/index/reindex.py
+++ b/tubearchivist/home/src/index/reindex.py
@@ -4,12 +4,16 @@ functionality:
 - index and update in es
 """

+import os
+import shutil
 from datetime import datetime
 from math import ceil
 from time import sleep

 from home.src.download.queue import PendingList
 from home.src.download.thumbnails import ThumbManager
+from home.src.download.yt_dlp_base import CookieHandler
+from home.src.download.yt_dlp_handler import VideoDownloader
 from home.src.es.connect import ElasticWrap
 from home.src.index.channel import YoutubeChannel
 from home.src.index.playlist import YoutubePlaylist
@@ -37,6 +41,13 @@ class Reindex:
        self.all_channel_ids = False
        self.all_playlist_ids = False

+    def check_cookie(self):
+        """validate cookie if enabled"""
+        if self.config["downloads"]["cookie_import"]:
+            valid = CookieHandler(self.config).validate()
+            if not valid:
+                return
+
    def _get_daily(self):
        """get daily refresh values"""
        total_videos = self._get_total_hits("ta_video")
@@ -150,6 +161,7 @@ class Reindex:
        date_downloaded = video.json_data["date_downloaded"]
        channel_dict = video.json_data["channel"]
        playlist = video.json_data.get("playlist")
+        subtitles = video.json_data.get("subtitles")

        # get new
        video.build_json()
@@ -157,7 +169,7 @@ class Reindex:
            video.deactivate()
            return

-        video.delete_subtitles()
+        video.delete_subtitles(subtitles=subtitles)
        video.check_subtitles()

        # add back
@@ -211,7 +223,12 @@ class Reindex:
        # videos
        print(f"reindexing {len(self.all_youtube_ids)} videos")
        for youtube_id in self.all_youtube_ids:
-            self._reindex_single_video(youtube_id)
+            try:
+                self._reindex_single_video(youtube_id)
+            except FileNotFoundError:
+                # handle channel name change here
+                ChannelUrlFixer(youtube_id, self.config).run()
+                self._reindex_single_video(youtube_id)
            if sleep_interval:
                sleep(sleep_interval)
        # channels
@@ -231,3 +248,62 @@ class Reindex:
                self._reindex_single_playlist(playlist_id, all_indexed_ids)
                if sleep_interval:
                    sleep(sleep_interval)
+
+
+class ChannelUrlFixer:
+    """fix not matching channel names in reindex"""
+
+    def __init__(self, youtube_id, config):
+        self.youtube_id = youtube_id
+        self.config = config
+        self.video = False
+
+    def run(self):
+        """check and run if needed"""
+        print(f"{self.youtube_id}: failed to build channel path, try to fix.")
+        video_path_is, video_folder_is = self.get_as_is()
+        if not os.path.exists(video_path_is):
+            print(f"giving up reindex, video in video: {self.video.json_data}")
+            raise ValueError
+
+        _, video_folder_should = self.get_as_should()
+
+        if video_folder_is != video_folder_should:
+            self.process(video_path_is)
+        else:
+            print(f"{self.youtube_id}: skip channel url fixer")
+
+    def get_as_is(self):
+        """get video object as is"""
+        self.video = YoutubeVideo(self.youtube_id)
+        self.video.get_from_es()
+        video_path_is = os.path.join(
+            self.config["application"]["videos"],
+            self.video.json_data["media_url"],
+        )
+        video_folder_is = os.path.split(video_path_is)[0]
+
+        return video_path_is, video_folder_is
+
+    def get_as_should(self):
+        """add fresh metadata from remote"""
+        self.video.get_from_youtube()
+        self.video.add_file_path()
+
+        video_path_should = os.path.join(
+            self.config["application"]["videos"],
+            self.video.json_data["media_url"],
+        )
+        video_folder_should = os.path.split(video_path_should)[0]
+        return video_path_should, video_folder_should
+
+    def process(self, video_path_is):
+        """fix filepath"""
+        print(f"{self.youtube_id}: fixing channel rename.")
+        cache_dir = self.config["application"]["cache_dir"]
+        new_file_path = os.path.join(
+            cache_dir, "download", self.youtube_id + ".mp4"
+        )
+        shutil.move(video_path_is, new_file_path)
+        VideoDownloader().move_to_archive(self.video.json_data)
+        self.video.update_media_url()
--- a/tubearchivist/home/src/index/video.py
+++ b/tubearchivist/home/src/index/video.py
@@ -10,9 +10,9 @@ from datetime import datetime

 import requests
 from django.conf import settings
-from home.src.download.thumbnails import ThumbManager
 from home.src.es.connect import ElasticWrap
 from home.src.index import channel as ta_channel
+from home.src.index import playlist as ta_playlist
 from home.src.index.generic import YouTubeItem
 from home.src.ta.helper import (
    DurationConverter,
@@ -67,7 +67,7 @@ class YoutubeSubtitle:
            return False

        video_media_url = self.video.json_data["media_url"]
-        media_url = video_media_url.replace(".mp4", f"-{lang}.vtt")
+        media_url = video_media_url.replace(".mp4", f".{lang}.vtt")
        all_formats = all_subtitles.get(lang)
        if not all_formats:
            return False
@@ -103,7 +103,7 @@ class YoutubeSubtitle:
            return False

        video_media_url = self.video.json_data["media_url"]
-        media_url = video_media_url.replace(".mp4", f"-{lang}.vtt")
+        media_url = video_media_url.replace(".mp4", f".{lang}.vtt")
        all_formats = all_subtitles.get(lang)
        if not all_formats:
            # no user subtitles found
@@ -152,6 +152,30 @@ class YoutubeSubtitle:
        """send subtitle to es for indexing"""
        _, _ = ElasticWrap("_bulk").post(data=query_str, ndjson=True)

+    def delete(self, subtitles=False):
+        """delete subtitles from index and filesystem"""
+        youtube_id = self.video.youtube_id
+        videos_base = self.video.config["application"]["videos"]
+        # delete files
+        if subtitles:
+            files = [i["media_url"] for i in subtitles]
+        else:
+            if not self.video.json_data.get("subtitles"):
+                return
+
+            files = [i["media_url"] for i in self.video.json_data["subtitles"]]
+
+        for file_name in files:
+            file_path = os.path.join(videos_base, file_name)
+            try:
+                os.remove(file_path)
+            except FileNotFoundError:
+                print(f"{youtube_id}: {file_path} failed to delete")
+        # delete from index
+        path = "ta_subtitle/_delete_by_query?refresh=true"
+        data = {"query": {"term": {"youtube_id": {"value": youtube_id}}}}
+        _, _ = ElasticWrap(path).post(data=data)
+

 class SubtitleParser:
    """parse subtitle str from youtube"""
@@ -170,9 +194,9 @@ class SubtitleParser:

        self.all_cues = []
        for idx, event in enumerate(all_events):
-            if "dDurationMs" not in event:
-                # some events won't have a duration
-                print(f"failed to parse event without duration: {event}")
+            if "dDurationMs" not in event or "segs" not in event:
+                # some events won't have a duration or segs
+                print(f"skipping subtitle event without content: {event}")
                continue

            cue = {
@@ -196,10 +220,16 @@ class SubtitleParser:

            if flatten:
                # fix overlapping retiming issue
-                last_end = flatten[-1]["tStartMs"] + flatten[-1]["dDurationMs"]
+                last = flatten[-1]
+                if "dDurationMs" not in last or "segs" not in last:
+                    # some events won't have a duration or segs
+                    print(f"skipping subtitle event without content: {event}")
+                    continue
+
+                last_end = last["tStartMs"] + last["dDurationMs"]
                if event["tStartMs"] < last_end:
-                    joined = flatten[-1]["segs"][0]["utf8"] + "\n" + text
-                    flatten[-1]["segs"][0]["utf8"] = joined
+                    joined = last["segs"][0]["utf8"] + "\n" + text
+                    last["segs"][0]["utf8"] = joined
                    continue

            event.update({"segs": [{"utf8": text}]})
@@ -309,7 +339,7 @@ class SponsorBlock:
        sb_id = RedisArchivist().get_message(key)
        if not sb_id["status"]:
            sb_id = {"status": randomizor(32)}
-            RedisArchivist().set_message(key, sb_id, expire=False)
+            RedisArchivist().set_message(key, sb_id)

        return sb_id

@@ -437,7 +467,8 @@ class YoutubeVideo(YouTubeItem, YoutubeSubtitle):
        upload_date_time = datetime.strptime(upload_date, "%Y%m%d")
        published = upload_date_time.strftime("%Y-%m-%d")
        last_refresh = int(datetime.now().strftime("%s"))
-        base64_blur = ThumbManager().get_base64_blur(self.youtube_id)
+        # base64_blur = ThumbManager().get_base64_blur(self.youtube_id)
+        base64_blur = False
        # build json_data basics
        self.json_data = {
            "title": self.youtube_meta["title"],
@@ -535,24 +566,43 @@ class YoutubeVideo(YouTubeItem, YoutubeSubtitle):

    def delete_media_file(self):
        """delete video file, meta data"""
+        print(f"{self.youtube_id}: delete video")
        self.get_from_es()
        video_base = self.app_conf["videos"]
-        to_del = [self.json_data.get("media_url")]
-
-        all_subtitles = self.json_data.get("subtitles")
-        if all_subtitles:
-            to_del = to_del + [i.get("media_url") for i in all_subtitles]
-
-        for media_url in to_del:
-            file_path = os.path.join(video_base, media_url)
-            try:
-                os.remove(file_path)
-            except FileNotFoundError:
-                print(f"{self.youtube_id}: failed {media_url}, continue.")
+        media_url = self.json_data.get("media_url")
+        file_path = os.path.join(video_base, media_url)
+        try:
+            os.remove(file_path)
+        except FileNotFoundError:
+            print(f"{self.youtube_id}: failed {media_url}, continue.")

+        self.del_in_playlists()
        self.del_in_es()
        self.delete_subtitles()

+    def del_in_playlists(self):
+        """remove downloaded in playlist"""
+        all_playlists = self.json_data.get("playlist")
+        if not all_playlists:
+            return
+
+        for playlist_id in all_playlists:
+            print(f"{playlist_id}: delete video {self.youtube_id}")
+            playlist = ta_playlist.YoutubePlaylist(playlist_id)
+            playlist.get_from_es()
+            entries = playlist.json_data["playlist_entries"]
+            for idx, entry in enumerate(entries):
+                if entry["youtube_id"] == self.youtube_id:
+                    playlist.json_data["playlist_entries"][idx].update(
+                        {"downloaded": False}
+                    )
+            playlist.upload_to_es()
+
+    def delete_subtitles(self, subtitles=False):
+        """delete indexed subtitles"""
+        print(f"{self.youtube_id}: delete subtitles")
+        YoutubeSubtitle(self).delete(subtitles=subtitles)
+
    def _get_ryd_stats(self):
        """get optional stats from returnyoutubedislikeapi.com"""
        try:
@@ -587,10 +637,10 @@ class YoutubeVideo(YouTubeItem, YoutubeSubtitle):
            self.json_data["subtitles"] = subtitles
            handler.download_subtitles(relevant_subtitles=subtitles)

-    def delete_subtitles(self):
-        """delete indexed subtitles"""
-        path = "ta_subtitle/_delete_by_query?refresh=true"
-        data = {"query": {"term": {"youtube_id": {"value": self.youtube_id}}}}
+    def update_media_url(self):
+        """update only media_url in es for reindex channel rename"""
+        data = {"doc": {"media_url": self.json_data["media_url"]}}
+        path = f"{self.index_name}/_update/{self.youtube_id}"
        _, _ = ElasticWrap(path).post(data=data)


--- a/tubearchivist/home/src/ta/config.py
+++ b/tubearchivist/home/src/ta/config.py
@@ -83,6 +83,7 @@ class AppConfig:

    def update_config(self, form_post):
        """update config values from settings form"""
+        updated = []
        for key, value in form_post.items():
            if not value and not isinstance(value, int):
                continue
@@ -96,8 +97,10 @@ class AppConfig:

            config_dict, config_value = key.split("_", maxsplit=1)
            self.config[config_dict][config_value] = to_write
+            updated.append((config_value, to_write))

-        RedisArchivist().set_message("config", self.config, expire=False)
+        RedisArchivist().set_message("config", self.config)
+        return updated

    @staticmethod
    def set_user_config(form_post, user_id):
@@ -108,7 +111,7 @@ class AppConfig:

            message = {"status": value}
            redis_key = f"{user_id}:{key}"
-            RedisArchivist().set_message(redis_key, message, expire=False)
+            RedisArchivist().set_message(redis_key, message)

    def get_colors(self):
        """overwrite config if user has set custom values"""
@@ -148,7 +151,7 @@ class AppConfig:
                    needs_update = True

        if needs_update:
-            RedisArchivist().set_message("config", redis_config, expire=False)
+            RedisArchivist().set_message("config", redis_config)


 class ScheduleBuilder:
@@ -162,6 +165,7 @@ class ScheduleBuilder:
        "run_backup": "0 18 0",
    }
    CONFIG = ["check_reindex_days", "run_backup_rotate"]
+    MSG = "message:setting"

    def __init__(self):
        self.config = AppConfig().config
@@ -177,25 +181,27 @@ class ScheduleBuilder:
                except ValueError:
                    print(f"failed: {key} {value}")
                    mess_dict = {
-                        "status": "message:setting",
+                        "status": self.MSG,
                        "level": "error",
                        "title": "Scheduler update failed.",
                        "message": "Invalid schedule input",
                    }
-                    RedisArchivist().set_message("message:setting", mess_dict)
+                    RedisArchivist().set_message(
+                        self.MSG, mess_dict, expire=True
+                    )
                    return

                redis_config["scheduler"][key] = to_write
            if key in self.CONFIG and value:
                redis_config["scheduler"][key] = int(value)
-        RedisArchivist().set_message("config", redis_config, expire=False)
+        RedisArchivist().set_message("config", redis_config)
        mess_dict = {
-            "status": "message:setting",
+            "status": self.MSG,
            "level": "info",
            "title": "Scheduler changed.",
            "message": "Please restart container for changes to take effect",
        }
-        RedisArchivist().set_message("message:setting", mess_dict)
+        RedisArchivist().set_message(self.MSG, mess_dict, expire=True)

    def value_builder(self, key, value):
        """validate single cron form entry and return cron dict"""
--- a/tubearchivist/home/src/ta/helper.py
+++ b/tubearchivist/home/src/ta/helper.py
@@ -11,7 +11,7 @@ import unicodedata
 from datetime import datetime
 from urllib.parse import parse_qs, urlparse

-import yt_dlp
+from home.src.download.yt_dlp_base import YtWrap


 def clean_string(file_name):
@@ -173,7 +173,7 @@ class UrlListParser:
            id_type = "video"
        elif str_len == 24:
            id_type = "channel"
-        elif str_len in [34, 18]:
+        elif str_len in [34, 18] or id_str in ["LL", "WL"]:
            id_type = "playlist"
        else:
            # unable to parse
@@ -184,14 +184,12 @@ class UrlListParser:
    @staticmethod
    def extract_channel_name(url):
        """find channel id from channel name with yt-dlp help"""
-        obs = {
-            "default_search": "ytsearch",
-            "quiet": True,
+        obs_request = {
            "skip_download": True,
            "extract_flat": True,
            "playlistend": 0,
        }
-        url_info = yt_dlp.YoutubeDL(obs).extract_info(url, download=False)
+        url_info = YtWrap(obs_request).extract(url)
        try:
            channel_id = url_info["channel_id"]
        except KeyError as error:
--- a/tubearchivist/home/src/ta/ta_redis.py
+++ b/tubearchivist/home/src/ta/ta_redis.py
@@ -8,7 +8,6 @@ import json
 import os

 import redis
-from home.src.ta.helper import ignore_filelist


 class RedisBase:
@@ -35,10 +34,10 @@ class RedisArchivist(RedisBase):
        "setting",
    ]

-    def set_message(self, key, message, expire=True):
+    def set_message(self, key, message, path=".", expire=False):
        """write new message to redis"""
        self.conn.execute_command(
-            "JSON.SET", self.NAME_SPACE + key, ".", json.dumps(message)
+            "JSON.SET", self.NAME_SPACE + key, path, json.dumps(message)
        )

        if expire:
@@ -81,6 +80,12 @@ class RedisArchivist(RedisBase):
        redis_lock = self.conn.lock(self.NAME_SPACE + lock_key)
        return redis_lock

+    def is_locked(self, lock_key):
+        """check if lock is set"""
+        lock_name = self.NAME_SPACE + lock_key
+        lock_status = bool(self.conn.execute_command("GET", lock_name))
+        return lock_status
+
    def get_progress(self):
        """get a list of all progress messages"""
        all_messages = []
@@ -95,27 +100,6 @@ class RedisArchivist(RedisBase):

        return all_messages

-    @staticmethod
-    def monitor_cache_dir(cache_dir):
-        """
-        look at download cache dir directly as alternative progress info
-        """
-        dl_cache = os.path.join(cache_dir, "download")
-        all_cache_file = os.listdir(dl_cache)
-        cache_file = ignore_filelist(all_cache_file)
-        if cache_file:
-            filename = cache_file[0][12:].replace("_", " ").split(".")[0]
-            mess_dict = {
-                "status": "message:download",
-                "level": "info",
-                "title": "Downloading: " + filename,
-                "message": "",
-            }
-        else:
-            return False
-
-        return mess_dict
-

 class RedisQueue(RedisBase):
    """dynamically interact with the download queue in redis"""
--- a/tubearchivist/home/tasks.py
+++ b/tubearchivist/home/tasks.py
@@ -48,7 +48,7 @@ def update_subscribed():
        "title": "Rescanning channels and playlists.",
        "message": "Looking for new videos.",
    }
-    RedisArchivist().set_message("message:rescan", message)
+    RedisArchivist().set_message("message:rescan", message, expire=True)

    have_lock = False
    my_lock = RedisArchivist().get_lock("rescan")
@@ -108,13 +108,14 @@ def download_single(youtube_id):
    try:
        have_lock = my_lock.acquire(blocking=False)
        if have_lock:
+            key = "message:download"
            mess_dict = {
-                "status": "message:download",
+                "status": key,
                "level": "info",
                "title": "Download single video",
                "message": "processing",
            }
-            RedisArchivist().set_message("message:download", mess_dict)
+            RedisArchivist().set_message(key, mess_dict, expire=True)
            VideoDownloader().run_queue()
        else:
            print("Download queue already running.")
@@ -196,7 +197,7 @@ def kill_dl(task_id):
        "title": "Canceling download process",
        "message": "Canceling download queue now.",
    }
-    RedisArchivist().set_message("message:download", mess_dict)
+    RedisArchivist().set_message("message:download", mess_dict, expire=True)


@shared_task
@@ -245,13 +246,14 @@ def subscribe_to(url_str):
            channel_id_sub, channel_subscribed=True
        )
        # notify for channels
+        key = "message:subchannel"
        message = {
-            "status": "message:subchannel",
+            "status": key,
            "level": "info",
            "title": "Subscribing to Channels",
            "message": f"Processing {counter} of {len(to_subscribe_list)}",
        }
-        RedisArchivist().set_message("message:subchannel", message=message)
+        RedisArchivist().set_message(key, message=message, expire=True)
        counter = counter + 1


@@ -260,13 +262,14 @@ def index_channel_playlists(channel_id):
    """add all playlists of channel to index"""
    channel = YoutubeChannel(channel_id)
    # notify
+    key = "message:playlistscan"
    mess_dict = {
-        "status": "message:playlistscan",
+        "status": key,
        "level": "info",
        "title": "Looking for playlists",
        "message": f'Scanning channel "{channel.youtube_id}" in progress',
    }
-    RedisArchivist().set_message("message:playlistscan", mess_dict)
+    RedisArchivist().set_message(key, mess_dict, expire=True)
    channel.index_channel_playlists()


--- a/tubearchivist/home/templates/home/channel_id.html
+++ b/tubearchivist/home/templates/home/channel_id.html
@@ -112,6 +112,8 @@
            </div>
        </div>
    {% endif %}
+</div>
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
    <div class="view-controls">
        <div class="toggle">
            <span>Hide watched videos:</span>
@@ -141,14 +143,24 @@
        </div>
        <div class="view-icons">
            <img src="{% static 'img/icon-sort.svg' %}" alt="sort-icon" onclick="showForm()" id="animate-icon">
+            {% if view_style == "grid" %}
+            <div class="grid-count">
+                {% if grid_items < 7 %}
+                    <img src="{% static 'img/icon-add.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"1"}}" alt="grid plus row">
+                {% endif %}
+                {% if grid_items > 3 %}
+                    <img src="{% static 'img/icon-substract.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"-1"}}" alt="grid minus row">
+                {% endif %}
+            </div>
+            {% endif %}
            <img src="{% static 'img/icon-gridview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="grid" alt="grid view">
            <img src="{% static 'img/icon-listview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="list" alt="list view">
        </div>
    </div>
 </div>
 <div id="player" class="player-wrapper"></div>
-<div class="boxed-content">
-    <div class="video-list {{ view_style }}">
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
+    <div class="video-list {{ view_style }} {% if view_style == "grid" %}grid-{{ grid_items }}{% endif %}">
        {% if results %}
            {% for video in results %}
                <div class="video-item {{ view_style }}">
--- a/tubearchivist/home/templates/home/downloads.html
+++ b/tubearchivist/home/templates/home/downloads.html
@@ -45,15 +45,6 @@
            <img src="{% static 'img/icon-listview.svg' %}" onclick="changeView(this)" data-origin="downloads" data-value="list" alt="list view">
        </div>
    </div>
-    <div class="title-split">
-        {% if show_ignored_only %}
-            <h2>Ignored from download</h2>
-            <button onclick="deleteQueue(this)" data-id="ignore" title="Delete all previously ignored videos from the queue">Delete all ignored</button>
-        {% else %}
-            <h2>Download queue</h2>
-            <button onclick="deleteQueue(this)" data-id="pending" title="Delete all pending videos from the queue">Delete all queued</button>
-        {% endif %}
-    </div>
    <h3>Total videos: {{ max_hits }}{% if max_hits == 10000 %}+{% endif %}</h3>
    <div class="dl-list {{ view_style }}">
        {% if results %}
--- a/tubearchivist/home/templates/home/home.html
+++ b/tubearchivist/home/templates/home/home.html
@@ -1,12 +1,12 @@
 {% extends "home/base.html" %}
 {% block content %}
 {% load static %}
-<div class="boxed-content">
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
    {% if continue_vids %}
        <div class="title-bar">
            <h1>Continue Watching</h1>
        </div>
-        <div class="video-list {{ view_style }}">
+        <div class="video-list {{ view_style }} {% if view_style == "grid" %}grid-{{ grid_items }}{% endif %}">
            {% for video in continue_vids %}
                <div class="video-item {{ view_style }}">
                    <a href="#player" data-id="{{ video.source.youtube_id }}" onclick="createPlayer(this)">
@@ -74,14 +74,24 @@
        </div>
        <div class="view-icons">
            <img src="{% static 'img/icon-sort.svg' %}" alt="sort-icon" onclick="showForm()" id="animate-icon">
+            {% if view_style == "grid" %}
+                <div class="grid-count">
+                    {% if grid_items < 7 %}
+                        <img src="{% static 'img/icon-add.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"1"}}" alt="grid plus row">
+                    {% endif %}
+                    {% if grid_items > 3 %}
+                        <img src="{% static 'img/icon-substract.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"-1"}}" alt="grid minus row">
+                    {% endif %}
+                </div>
+            {% endif %}
            <img src="{% static 'img/icon-gridview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="grid" alt="grid view">
            <img src="{% static 'img/icon-listview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="list" alt="list view">
        </div>
    </div>
 </div>
 <div id="player" class="player-wrapper"></div>
-<div class="boxed-content">
-    <div class="video-list {{ view_style }}">
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
+    <div class="video-list {{ view_style }} {% if view_style == "grid" %}grid-{{ grid_items }}{% endif %}">
        {% if results %}
            {% for video in results %}
                <div class="video-item {{ view_style }}">
--- a/tubearchivist/home/templates/home/playlist_id.html
+++ b/tubearchivist/home/templates/home/playlist_id.html
@@ -63,6 +63,8 @@
            </div>
        </div>
    {% endif %}
+</div>
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
    <div class="view-controls">
        <div class="toggle">
            <span>Hide watched videos:</span>
@@ -76,14 +78,24 @@
            </div>
        </div>
        <div class="view-icons">
+            {% if view_style == "grid" %}
+            <div class="grid-count">
+                {% if grid_items < 7 %}
+                    <img src="{% static 'img/icon-add.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"1"}}" alt="grid plus row">
+                {% endif %}
+                {% if grid_items > 3 %}
+                    <img src="{% static 'img/icon-substract.svg' %}" onclick="changeGridItems(this)" data-value="{{ grid_items|add:"-1"}}" alt="grid minus row">
+                {% endif %}
+            </div>
+            {% endif %}
            <img src="{% static 'img/icon-gridview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="grid" alt="grid view">
            <img src="{% static 'img/icon-listview.svg' %}" onclick="changeView(this)" data-origin="home" data-value="list" alt="list view">
        </div>
    </div>
 </div>
 <div id="player" class="player-wrapper"></div>
-<div class="boxed-content">
-    <div class="video-list {{ view_style }}">
+<div class="boxed-content {% if view_style == "grid" %}boxed-{{ grid_items }}{% endif %}">
+    <div class="video-list {{ view_style }} {% if view_style == "grid" %}grid-{{ grid_items }}{% endif %}">
        {% if results %}
            {% for video in results %}
                <div class="video-item {{ view_style }}">
--- a/tubearchivist/home/templates/home/search.html
+++ b/tubearchivist/home/templates/home/search.html
@@ -1,7 +1,7 @@
 {% extends "home/base.html" %}
 {% block content %}
 <div id="player" class="player-wrapper"></div>
-<div class="boxed-content">
+<div class="boxed-content {% if all_styles.home == "grid" %}boxed-{{ grid_items }}{% endif %}">
    <div class="title-bar">
        <h1>Search your Archive</h1>
    </div>
@@ -10,7 +10,7 @@
    </div>
    <div class="multi-search-result">
        <h2>Video Results</h2>
-        <div id="video-results" class="video-list {{ all_styles.home }}">
+        <div id="video-results" class="video-list {{ all_styles.home }} {% if all_styles.home == "grid" %}grid-{{ grid_items }}{% endif %}">
            <p>No videos found.</p>
        </div>
    </div>
--- a/tubearchivist/home/templates/home/settings.html
+++ b/tubearchivist/home/templates/home/settings.html
@@ -114,6 +114,20 @@
                {{ app_form.downloads_subtitle_index }}
            </div>
        </div>
+        <div class="settings-group">
+            <h2 id="format">Cookie</h2>
+            <div class="settings-item">
+                <p>Import YouTube cookie: <span class="settings-current">{{ config.downloads.cookie_import }}</span><br></p>
+                <p>For automatic cookie import use <b>Tube Archivist Companion</b> <a href="https://github.com/tubearchivist/browser-extension" target="_blank">browser extension</a>.</p> 
+                <i>For manual cookie import, place your cookie file named <span class="settings-current">cookies.google.txt</span> in <span class="settings-current">cache/import</span> before enabling. Instructions in the <a href="https://github.com/tubearchivist/tubearchivist/wiki/Settings" target="_blank">Wiki.</a></i><br>
+                {{ app_form.downloads_cookie_import }}<br>
+                {% if config.downloads.cookie_import %}
+                    <div id="cookieMessage">
+                        <button onclick="handleCookieValidate()" type="button" id="cookieButton">Validate Cookie File</button>
+                    </div>
+                {% endif %}
+            </div>
+        </div>
        <div class="settings-group">
            <h2 id="integrations">Integrations</h2>
            <div class="settings-item">
@@ -256,6 +270,12 @@
    <div class="title-bar">
        <h1>Actions</h1>
    </div>
+    <div class="settings-group">
+        <h2>Delete download queue</h2>
+        <p>Delete your pending or previously ignored videos from your download queue.<p>
+        <button onclick="deleteQueue(this)" id="ignore-button" data-id="ignore" title="Delete all previously ignored videos from the queue">Delete all ignored</button>
+        <button onclick="deleteQueue(this)" id="pending-button" data-id="pending" title="Delete all pending videos from the queue">Delete all queued</button>
+    </div>
    <div class="settings-group">
        <h2>Manual media files import.</h2>
        <p>Add files to the <span class="settings-current">cache/import</span> folder. Make sure to follow the instructions in the Github <a href="https://github.com/tubearchivist/tubearchivist/wiki/Settings" target="_blank">Wiki</a>.</p>
--- a/tubearchivist/home/views.py
+++ b/tubearchivist/home/views.py
@@ -14,6 +14,7 @@ from django.contrib.auth.forms import AuthenticationForm
 from django.http import JsonResponse
 from django.shortcuts import redirect, render
 from django.views import View
+from home.src.download.yt_dlp_base import CookieHandler
 from home.src.es.index_setup import get_available_backups
 from home.src.frontend.api_calls import PostData
 from home.src.frontend.forms import (
@@ -76,6 +77,15 @@ class ArchivistViewConfig(View):

        return view_style

+    def _get_grid_items(self):
+        """return items per row to show in grid view"""
+        grid_key = f"{self.user_id}:grid_items"
+        grid_items = self.user_conf.get_message(grid_key)["status"]
+        if not grid_items:
+            grid_items = self.default_conf["default_view"]["grid_items"]
+
+        return grid_items
+
    def get_all_view_styles(self):
        """get dict of all view stiles for search form"""
        all_keys = ["channel", "playlist", "home"]
@@ -119,6 +129,7 @@ class ArchivistViewConfig(View):
            "sort_by": self._get_sort_by(),
            "sort_order": self._get_sort_order(),
            "view_style": self._get_view_style(),
+            "grid_items": self._get_grid_items(),
            "hide_watched": self._get_hide_watched(),
            "show_ignored_only": self._get_show_ignore_only(),
            "show_subed_only": self._get_show_subed_only(),
@@ -383,14 +394,15 @@ class DownloadView(ArchivistResultsView):
                youtube_ids = UrlListParser(url_str).process_list()
            except ValueError:
                # failed to process
+                key = "message:add"
                print(f"failed to parse: {url_str}")
                mess_dict = {
-                    "status": "message:add",
+                    "status": key,
                    "level": "error",
                    "title": "Failed to extract links.",
                    "message": "Not a video, channel or playlist ID or URL",
                }
-                RedisArchivist().set_message("message:add", mess_dict)
+                RedisArchivist().set_message(key, mess_dict, expire=True)
                return redirect("downloads")

            print(youtube_ids)
@@ -501,13 +513,14 @@ class ChannelView(ArchivistResultsView):
        """handle http post requests"""
        subscribe_form = SubscribeToChannelForm(data=request.POST)
        if subscribe_form.is_valid():
+            key = "message:subchannel"
            message = {
-                "status": "message:subchannel",
+                "status": key,
                "level": "info",
                "title": "Subscribing to Channels",
                "message": "Parsing form data",
            }
-            RedisArchivist().set_message("message:subchannel", message=message)
+            RedisArchivist().set_message(key, message=message, expire=True)
            url_str = request.POST.get("subscribe")
            print(url_str)
            subscribe_to.delay(url_str)
@@ -648,15 +661,14 @@ class PlaylistView(ArchivistResultsView):
        if subscribe_form.is_valid():
            url_str = request.POST.get("subscribe")
            print(url_str)
+            key = "message:subplaylist"
            message = {
-                "status": "message:subplaylist",
+                "status": key,
                "level": "info",
                "title": "Subscribing to Playlists",
                "message": "Parsing form data",
            }
-            RedisArchivist().set_message(
-                "message:subplaylist", message=message
-            )
+            RedisArchivist().set_message(key, message=message, expire=True)
            subscribe_to.delay(url_str)

        sleep(1)
@@ -791,21 +803,22 @@ class SettingsView(View):
        token = Token.objects.get_or_create(user=request.user)[0]
        return token

-    @staticmethod
-    def post(request):
+    def post(self, request):
        """handle form post to update settings"""
        user_form = UserSettingsForm(request.POST)
+        config_handler = AppConfig()
        if user_form.is_valid():
            user_form_post = user_form.cleaned_data
            if any(user_form_post.values()):
-                AppConfig().set_user_config(user_form_post, request.user.id)
+                config_handler.set_user_config(user_form_post, request.user.id)

        app_form = ApplicationSettingsForm(request.POST)
        if app_form.is_valid():
            app_form_post = app_form.cleaned_data
            if app_form_post:
                print(app_form_post)
-                AppConfig().update_config(app_form_post)
+                updated = config_handler.update_config(app_form_post)
+                self.post_process_updated(updated, config_handler.config)

        scheduler_form = SchedulerSettingsForm(request.POST)
        if scheduler_form.is_valid():
@@ -817,6 +830,35 @@ class SettingsView(View):
        sleep(1)
        return redirect("settings", permanent=True)

+    def post_process_updated(self, updated, config):
+        """apply changes for config"""
+        if not updated:
+            return
+
+        for config_value, updated_value in updated:
+            if config_value == "cookie_import":
+                self.process_cookie(config, updated_value)
+
+    @staticmethod
+    def process_cookie(config, updated_value):
+        """import and validate cookie"""
+        handler = CookieHandler(config)
+        if updated_value:
+            handler.import_cookie()
+            valid = handler.validate()
+            if not valid:
+                handler.revoke()
+                key = "message:setting"
+                message = {
+                    "status": key,
+                    "level": "error",
+                    "title": "Cookie import failed",
+                    "message": "",
+                }
+                RedisArchivist().set_message(key, message=message, expire=True)
+        else:
+            handler.revoke()
+

 def progress(request):
    # pylint: disable=unused-argument
--- a/tubearchivist/requirements.txt
+++ b/tubearchivist/requirements.txt
@@ -1,12 +1,12 @@
 beautifulsoup4==4.11.1
-celery==5.2.6
-Django==4.0.4
-django-cors-headers==3.11.0
+celery==5.2.7
+Django==4.0.5
+django-cors-headers==3.13.0
 djangorestframework==3.13.1
-Pillow==9.1.0
-redis==4.2.2
-requests==2.27.1
+Pillow==9.2.0
+redis==4.3.4
+requests==2.28.1
 ryd-client==0.0.3
 uWSGI==2.0.20
-whitenoise==6.0.0
-yt_dlp==2022.4.8
+whitenoise==6.2.0
+yt_dlp==2022.6.29
--- a/tubearchivist/static/css/style.css
+++ b/tubearchivist/static/css/style.css
@@ -133,6 +133,18 @@ button:hover {
    margin: 0 auto;
 }

+.boxed-content.boxed-4 {
+    max-width: 1200px;
+    width: 80%;
+}
+
+.boxed-content.boxed-5,
+.boxed-content.boxed-6,
+.boxed-content.boxed-7 {
+    max-width: unset;
+    width: 85%;
+}
+
 .round-img img {
    border-radius: 50%;
 }
@@ -328,7 +340,8 @@ button:hover {
    margin: 15px 0;
 }

-.view-icons {
+.view-icons,
+.grid-count {
    display: flex;
    justify-content: end;
 }
@@ -340,6 +353,13 @@ button:hover {
    filter: var(--img-filter);
 }

+.grid-count img {
+    width: 15px;
+    margin: 5px;
+    cursor: pointer;
+    filter: var(--img-filter);
+}
+
 #hidden-form {
    display: none;
 }
@@ -395,10 +415,26 @@ button:hover {
    margin-top: 1rem;
 }

-.video-list.grid {
+.video-list.grid.grid-3 {
    grid-template-columns: 1fr 1fr 1fr;
 }

+.video-list.grid.grid-4 {
+    grid-template-columns: 1fr 1fr 1fr 1fr;
+}
+
+.video-list.grid.grid-5 {
+    grid-template-columns: 1fr 1fr 1fr 1fr 1fr;
+}
+
+.video-list.grid.grid-6 {
+    grid-template-columns: 1fr 1fr 1fr 1fr 1fr 1fr;
+}
+
+.video-list.grid.grid-7 {
+    grid-template-columns: 1fr 1fr 1fr 1fr 1fr 1fr 1fr;
+}
+
 .video-list.list {
    grid-template-columns: unset;
 }
@@ -1050,11 +1086,19 @@ button:hover {
 }

 /* tablet */
-@media screen and (max-width: 1000px) {
-    .boxed-content {
+@media screen and (max-width: 1000px), screen and (max-height: 850px) {
+    .boxed-content,
+    .boxed-content.boxed-4,
+    .boxed-content.boxed-5,
+    .boxed-content.boxed-6,
+    .boxed-content.boxed-7 {
        width: 90%;
    }
-    .video-list.grid,
+    .video-list.grid.grid-3,
+    .video-list.grid.grid-4,
+    .video-list.grid.grid-5,
+    .video-list.grid.grid-6,
+    .video-list.grid.grid-7,
    .dl-list.grid,
    .channel-list.grid,
    .playlist-list.grid {
@@ -1084,6 +1128,9 @@ button:hover {
        position: unset;
        transform: unset;
    }
+    .grid-count {
+        display: none;
+    }
    .video-player {
        height: unset;
        padding: 20px 0
@@ -1098,7 +1145,11 @@ button:hover {
    * {
        word-wrap: anywhere;
    }
-    .video-list.grid,
+    .video-list.grid.grid-3,
+    .video-list.grid.grid-4,
+    .video-list.grid.grid-5,
+    .video-list.grid.grid-6,
+    .video-list.grid.grid-7,
    .dl-list.grid,
    .channel-list.grid,
    .video-item.list,
--- a/tubearchivist/static/img/icon-substract.svg
+++ b/tubearchivist/static/img/icon-substract.svg
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="474.99609"
+   height="78.428696"
+   viewBox="0 0 125.67634 20.750926"
+   version="1.1"
+   id="svg1303"
+   inkscape:version="0.92.4 (5da689c313, 2019-01-14)"
+   sodipodi:docname="icon-add.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <defs
+     id="defs1297" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.85859018"
+     inkscape:cx="-97.380081"
+     inkscape:cy="261.09215"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     units="px"
+     inkscape:window-width="1920"
+     inkscape:window-height="1017"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     showguides="true"
+     inkscape:guide-bbox="true"
+     inkscape:showpageshadow="2"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1">
+    <sodipodi:guide
+       position="-225.18364,87.524084"
+       orientation="1,0"
+       id="guide1072"
+       inkscape:locked="false" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata1300">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Ebene 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-3.3077777,-220.4781)">
+    <path
+       style="opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:markers fill stroke"
+       d="m 12.291019,220.47796 c -4.9648228,-0.009 -8.9691711,3.98046 -8.9784054,8.94536 l -0.00482,2.62846 c -0.00925,4.9649 3.9804459,8.96933 8.9452674,8.97832 107.703889,0.29274 22.266017,0.0414 107.747629,0.19881 4.96484,0.009 8.96917,-3.98046 8.9784,-8.94534 l 0.005,-2.62847 c 0.009,-4.96489 -3.98037,-8.96923 -8.94525,-8.97831 -107.850822,-0.0255 -20.413204,-0.038 -107.747821,-0.19883 z"
+       id="rect1073"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="ccccccccc" />
+  </g>
+</svg>
--- a/tubearchivist/static/script.js
+++ b/tubearchivist/static/script.js
@@ -121,6 +121,16 @@ function changeView(image) {
    }, 500);
 }

+function changeGridItems(image) {
+    var operator = image.getAttribute("data-value");
+    var payload = JSON.stringify({'change_grid': operator});
+    sendPost(payload);
+    setTimeout(function(){
+        location.reload();
+        return false;
+    }, 500);
+}
+
 function toggleCheckbox(checkbox) {
    // pass checkbox id as key and checkbox.checked as value
    var toggleId = checkbox.id;
@@ -193,10 +203,10 @@ function deleteQueue(button) {
    var to_delete = button.getAttribute('data-id');
    var payload = JSON.stringify({'deleteQueue': to_delete});
    sendPost(payload);
-    setTimeout(function(){
-        location.reload();
-        return false;
-    }, 1000);
+    // clear button
+    var message = document.createElement('p');
+    message.innerText = 'deleting download queue: ' + to_delete;
+    document.getElementById(button.id).replaceWith(message);
 }

 function stopQueue() {
@@ -350,7 +360,10 @@ function createPlayer(button) {
                `;
            }
        }
+    } else {
+        sponsorBlock = null;
    }
+
    var videoProgress = getVideoProgress(videoId).position;
    var videoName = videoData.data.title;

@@ -696,6 +709,24 @@ function postSponsorSegmentVote(videoId, uuid, vote) {
    apiRequest(apiEndpoint, "POST", data);
 }

+function handleCookieValidate() {
+    document.getElementById("cookieButton").remove();
+    var cookieMessageElement = document.getElementById("cookieMessage");
+    cookieMessageElement.innerHTML = `<span>Processing.</span>`;
+    response = postCookieValidate();
+    if (response.cookie_validated == true) {
+        cookieMessageElement.innerHTML = `<span>The cookie file is valid.</span>`;
+    } else {
+        cookieMessageElement.innerHTML = `<span class="danger-zone">Warning, the cookie file is invalid.</span>`;
+    }
+}
+
+// Check youtube cookie settings
+function postCookieValidate() {
+    var apiEndpoint = "/api/cookie/";
+    return apiRequest(apiEndpoint, "POST");
+}
+
 // Makes api requests when passed an endpoint and method ("GET", "POST", "DELETE")
 function apiRequest(apiEndpoint, method, data) {
    const xhttp = new XMLHttpRequest();
@@ -754,21 +785,25 @@ function setProgressBar(videoId, currentTime, duration) {
 }

 // multi search form
+let searchTimeout = null;
 function searchMulti(query) {
-    if (query.length > 1) {
-        var payload = JSON.stringify({'multi_search': query});
-        var http = new XMLHttpRequest();
-        http.onreadystatechange = function() {
-            if (http.readyState === 4) {
-                allResults = JSON.parse(http.response).results;
-                populateMultiSearchResults(allResults);
-            }
-        };
-        http.open("POST", "/process/", true);
-        http.setRequestHeader("X-CSRFToken", getCookie("csrftoken"));
-        http.setRequestHeader("Content-type", "application/json");
-        http.send(payload);
-    }
+    clearTimeout(searchTimeout);
+    searchTimeout = setTimeout(function () {
+        if (query.length > 1) {
+            var payload = JSON.stringify({'multi_search': query});
+            var http = new XMLHttpRequest();
+            http.onreadystatechange = function() {
+                if (http.readyState === 4) {
+                    allResults = JSON.parse(http.response).results;
+                    populateMultiSearchResults(allResults);
+                }
+            };
+            http.open("POST", "/process/", true);
+            http.setRequestHeader("X-CSRFToken", getCookie("csrftoken"));
+            http.setRequestHeader("Content-type", "application/json");
+            http.send(payload);
+        }
+    }, 500);
 }

 function getViewDefaults(view) {
Author	SHA1	Message	Date
simon	6d59da4c86	remove redundant latest tags	2022-07-03 18:20:30 +07:00
simon	5bc67104ea	set restart policy to unless-stopped	2022-07-03 17:23:02 +07:00
simon	72ec78e011	browser extension as prefered cookie sync method	2022-07-03 16:46:45 +07:00
simon	de8b7d6b43	bump ES version	2022-07-03 16:09:09 +07:00
simon	048409bb1e	bump TA_VERSION to v0.1.7	2022-07-03 16:08:30 +07:00
simon	efff4cd96d	change cookie documentation for v0.1.7	2022-07-03 16:06:28 +07:00
simon	78d7947a5c	a note about subtitle refresh, #260	2022-07-03 15:36:21 +07:00
simon	c132a37f03	bump dependencies	2022-07-03 15:30:46 +07:00
simon	4678a7507b	bump dependencies	2022-06-30 18:44:33 +07:00
simon	e8e240c89b	Startup fix, cookie improvements, #build Changed - lock creating superuser at startup by @dshoreman - auto validate cookie - API: return cookie validation state for browser extension - Finetuning CSS mobile layout	2022-06-27 10:14:59 +07:00
simon	1857ac44ca	fix tablet css breakpoints and grid spacing	2022-06-27 09:48:36 +07:00
simon	8c07932071	delete cookie:valid key when revoking	2022-06-23 19:21:13 +07:00
simon	74d74d95a1	store validation result, return in API	2022-06-23 06:48:55 +07:00
simon	b4add20d10	bump yt-dlp	2022-06-22 19:30:38 +07:00
Dave Shoreman	e9619c1242	Fix repeated superuser creations after rename/removal (#263 ) * Avoid creating superuser if variables are removed Enables the removal of `TA_USERNAME` and/or `TA_PASSWORD` as a way of preventing an additional superuser being created when another exists. In the old code, `ELASTIC_USER` would never error due to the default, so this replaces the loop with one requirement on `ELASTIC_PASSWORD`. * Use .superuser_created to prevent re-creation Creates an empty `.superuser_created` file after successful creation, and uses this to skip the command on future runs. If the file doesn't exist, then `TA_USERNAME` and `TA_PASSWORD` will also be required. * The superuser password can't be empty ...well—it can—but the password input of the login form requires a value so even though the account is created, you can't actually login. * Parse createsuperuser output for 'exists' error If a user already exists with the same name as the superuser being created, the command fails with "Error: That name is already taken". It's probably safe to assume that user is the one we expect. This parses the output, treating it as successful so it can be skipped next time. If it hits the catch-all, something probably failed so we exit. * Use the cache for persistence Updates the .superuser_created file to be placed in /cache so that it gets persisted in a volume between config tweaks and container rebuilds. Also makes `TA_PASSWORD` required always, because it seems to be needed by tubearchivist/config/settings.py to generate a secret key. * Let it work outside Docker If /cache doesn't exist (i.e. when it's not running in Docker), this falls back to a `cache` dir in the current working directory instead. Also renames the file to 'initsu.lock' rather than having it hidden. * Use flexible fallback path for `celery` command	2022-06-22 18:29:46 +07:00
simon	49d33a2765	Improved Cookie handeling, #build Changed: - Cookie: Use IO Stream from Redis directly for cookies - Cookie: Don't load invalid cookie - API: Import cookie with PUT request - Redis: Don't expire Redis messages by default - Redis: Connections expire automatically	2022-06-21 08:14:01 +07:00
simon	ecc58f6c11	API: note about release lagging behind	2022-06-21 08:10:00 +07:00
simon	e5f43e5fe9	API: implement cookie PUT request to import cookie	2022-06-21 08:06:38 +07:00
simon	499c47c7a1	move set_cookie to separate method for reusabliity	2022-06-21 08:01:33 +07:00
simon	2cf30e1127	refactor: default set_message in RedisArchivist to True	2022-06-16 10:37:46 +07:00
simon	ebfc4a349f	center title and tiles	2022-06-15 18:30:06 +07:00
simon	150c1dc273	add tiles to readme	2022-06-15 18:18:52 +07:00
simon	30abbe9be7	rewrite cookie into redis from io stream, auto validate	2022-06-15 17:54:05 +07:00
simon	40e4ef0e05	auto expire redis connections after 3600secs	2022-06-15 16:36:41 +07:00
simon	2ceb1b701a	consolidate config of cookie revoke	2022-06-15 15:39:24 +07:00
simon	2ad093a9a8	handle cookiejar.LoadError dont import invalid cookie	2022-06-15 10:39:48 +07:00
simon	09a94d0df5	set relative values directly with path arg	2022-06-15 10:27:29 +07:00
simon	f7f4ca7728	API update, #build Changed: - API: Added Task get view - Added is_locked method for redis lock check - Updaded base and libs	2022-06-15 09:24:01 +07:00
simon	83a90000c6	bump base image	2022-06-15 09:23:41 +07:00
lamusmaser	bbb16bb3c2	Update TaskAPIView with GET - #257 PR (#258 ) * Initial commit for GET response for TaskAPIView. * Update for missing space - linting issue. * Additional linting fixes. * add is_locked method to check if lock is set * Update to use `.is_locked` method and add decorator. * Fix linting issue. * Fix doubled "rescan" call for locked file. Removed call to ".owned()" under "is_locked". * Commenting out GET call in TaskAPI view to revert change for testing. * Commenting is_locked function to see if Server Response 500 is stopped. * Reassert is_locked function within RedisArchivist class. * Create test GET responder. * Reverting simple GET response change. * Reapplying simple GET response for `/api/task/`. * Reapplying change with modification to lock key. * Documentation update for new GET calls. * README: fix returned value as `bool` instead of `str`. * Updating the `is_locked` key reference to "rescan" and "downloading" to fix which key is being retrieved. * Use dictionary keys, rather than line-by-line statements. * Fix typo in README for Task View. Co-authored-by: simon <simobilleter@gmail.com>	2022-06-15 09:15:59 +07:00
simon	4d9ee4494f	bump requests	2022-06-14 14:26:49 +07:00
simon	eeeabca8c2	bump dependencies	2022-06-07 17:09:49 +07:00
simon	bb0f3dad1a	update roadmap	2022-06-04 11:19:47 +07:00
simon	9c0c263fce	new docker build for build server task	2022-06-04 11:16:46 +07:00
simon	aed2d34149	Merge branch 'testing' for release v0.1.6	2022-06-04 10:15:24 +07:00
simon	3504408e70	update TA_VERSION to v0.1.6	2022-06-04 09:47:51 +07:00
simon	41b3e06f73	update docs for v0.1.6	2022-06-01 17:00:06 +07:00
simon	c41f0a7cc4	try to LOAD_TRUNCATED_IMAGES, #256	2022-06-01 09:04:55 +07:00
simon	19d9af821d	grid row ui improvements, #build Changed: - Better styled grid row, hid controlls if not applicable - Changed subtitle naming convention - Timeout for search as you type - move delete queue button to settings page	2022-05-31 16:40:54 +07:00
simon	5d262d7d48	skip cookie if no config added to YtWrap	2022-05-30 18:22:17 +07:00
simon	231ac1e012	make channel matching optional for reusability	2022-05-30 17:59:52 +07:00
simon	cbb714c235	show grid count controls only if applicable	2022-05-30 16:21:24 +07:00
simon	c93e935b9c	move delete download queue button to settings page	2022-05-30 16:06:12 +07:00
simon	c6d696a91b	timeout search as you type	2022-05-30 15:29:52 +07:00
simon	a9b8d34b5a	adapt search width with grid_items	2022-05-30 14:52:47 +07:00
simon	25e2bdb0b7	bump celery version	2022-05-30 14:51:44 +07:00
simon	bbb0c26498	fix subtitle delete overwrite, change filename to .lang.vtt, #195	2022-05-29 11:43:25 +07:00
simon	386c456415	variable gird row items, #build Changed: - implemented configurable video items in grid row - fix subtitle parser bug with missing segs key - fix also delete video from playlist - fix channel video extractor after refactor	2022-05-28 21:54:47 +07:00
simon	51a45bb59e	implement variable grid row size for playlist_id	2022-05-28 21:48:15 +07:00
simon	0759b4f220	reset mobile variable gird row count	2022-05-28 21:41:17 +07:00
simon	9f92bf95b4	mark video as downloaded false when deleting video	2022-05-28 21:23:56 +07:00
simon	e638f8b487	skip subtitle segment without segs key, #249	2022-05-28 17:47:21 +07:00
simon	caaed252f9	specify videos page for get_last_youtube_videos of channel	2022-05-28 14:34:01 +07:00
simon	5982932457	implement variable grid row size	2022-05-28 13:57:29 +07:00
simon	9a31243b1c	log message when skipping video	2022-05-28 11:11:09 +07:00
simon	88e526f5e5	refactor new YtWrap class for yt-dlp calls, #build Changed: - new yt-dlp base class - new cookie class using io_stream - MetadataFromField postprocessors	2022-05-25 16:15:38 +07:00
Clark	730ac15349	Fix #241 Use title/uploader for embedded metadata not Content ID (#252 )	2022-05-25 16:13:25 +07:00
simon	0ac9243389	remove unused monitor_cache_dir method	2022-05-24 15:54:41 +07:00
simon	c39f8a9cb8	refactor use cookie io_stream	2022-05-24 15:51:58 +07:00
simon	9dd1e9a29f	extract playlists with new YtBase class	2022-05-24 10:44:18 +07:00
simon	3f5104d6d8	integrate new YtWrap class in download queue and subscriptions classes	2022-05-24 10:36:39 +07:00
simon	4b00f454b7	integrate new YtWrap class in yt_dlp handler	2022-05-24 10:19:02 +07:00
simon	33f27f018f	handle download error	2022-05-24 10:18:33 +07:00
simon	a7d9b4584b	implement new YtBase class for index classes	2022-05-24 10:01:30 +07:00
simon	4e699621a0	obs base and handle extract error	2022-05-24 10:00:40 +07:00
Heavybullets8	2dd51c38a7	Add Truenas Scale Instructions (#251 ) included two <br /> to add spacing between the guides. If the website results in an ssl error at the time of submitting its because the new site is still in the process of being handed over to a different registrar, and its still getting its certs from github. Should be fixed by tomorrow.	2022-05-24 08:53:34 +07:00
simon	37e6f8656a	yt-dlp base class	2022-05-24 08:53:05 +07:00
simon	1fd9981273	test new build server, #build Changed: - updated libraries - trigger unstable build on new buildserver	2022-05-20 20:27:30 +07:00
simon	3a2a7dac40	update dev environment details	2022-05-20 20:26:31 +07:00
simon	ef69ab2799	test new build server, #build Changed: - updated libraries - trigger unstable build on new buildserver	2022-05-20 20:10:18 +07:00
simon	f49e313e2f	add dl speed schedule to roadmap	2022-05-20 20:09:06 +07:00
simon	9fe6d41320	update libraries	2022-05-20 20:05:31 +07:00
simon	c0ccc267c8	remove drone	2022-05-20 19:37:42 +07:00
simon	1aef0451b7	Merge branch 'master' into testing	2022-05-20 18:31:15 +07:00
simon	e8763b87cc	fix manifest docker_token	2022-05-13 11:53:34 +07:00
simon	03527b4ace	add manifest pipeline	2022-05-12 21:50:37 +07:00
simon	526d75af4f	add arm64 build	2022-05-12 16:33:18 +07:00
simon	7e515b52e1	add TARGETPLATFORM build_args	2022-05-12 00:20:57 +07:00
simon	3679d28ffe	use docker_token instead	2022-05-11 23:39:34 +07:00
simon	ced2452d6e	image_pull_secrets with new creds	2022-05-11 22:42:30 +07:00
simon	b301a89ce1	change docker login	2022-05-11 22:29:04 +07:00
simon	0749cdd8f3	add TARGETPLATFORM env var	2022-05-11 21:59:15 +07:00
simon	da251b28a4	remove dry_run	2022-05-11 21:42:16 +07:00
simon	5bccbfbd84	explicitly set platform	2022-05-11 21:37:03 +07:00
simon	1f0ef10d35	test build to other account	2022-05-11 21:26:24 +07:00
simon	ab6689c7c8	test dockerconfigjson	2022-05-11 21:17:37 +07:00
simon	ddc3ea5e72	test drone pipeline	2022-05-11 19:15:47 +07:00
simon	669f1ffe2c	dest drone pipeline	2022-05-11 18:44:57 +07:00
simon	03179eea94	bump redis	2022-05-10 16:32:18 +07:00
simon	e763c6d13e	merge for v0.1.5 build	2022-05-08 08:25:10 +07:00
simon	14387eb8d6	update roadmap	2022-05-08 08:18:17 +07:00
simon	619370c670	add metrics to extended universe	2022-05-08 08:06:59 +07:00
simon	ca13ddec26	update es version	2022-05-08 08:06:37 +07:00
simon	0ab809447a	update version	2022-05-07 19:06:43 +07:00
simon	f94bbec672	add cookie wiki link	2022-05-07 19:00:40 +07:00
simon	8cc6e77169	switch to compose v2	2022-05-07 18:33:16 +07:00
simon	5f63dc93ae	add Extended Universe section to readme	2022-05-07 10:09:53 +07:00
simon	3722f11a65	cleanup cookie file after task	2022-05-07 09:34:51 +07:00
simon	087043811f	avoid unneeded cookie open	2022-05-07 09:34:33 +07:00
simon	3ca86ba91d	fix typo, improve wording, add ansible docker playbook	2022-05-06 10:17:23 +07:00
simon	93265a8dca	implement cookie validation, #build Changed: - Added cookie validation button - Fixed all the open bug reports! :-)	2022-05-06 08:13:26 +07:00
simon	160c23c36c	conform import path style	2022-05-06 08:09:19 +07:00
simon	891911e56b	note about cookie validation	2022-05-06 08:02:34 +07:00
simon	94fa191fb8	skip premium videos, clean exit for empty bulk_list, #237	2022-05-05 23:38:10 +07:00
simon	9a2b29c2ae	implement channle name change in reindex, #211	2022-05-05 22:59:56 +07:00
simon	7a51368955	fix skip deleting none existing subtitles, add update_media_url	2022-05-05 22:56:22 +07:00
simon	7fa0d0f331	untangle delete subtitles from delete media file, #195	2022-05-05 09:11:37 +07:00
Nathan DeTar	4eba36f7a0	Cookie Validation Button (#242 ) * Added cookie validate button & message placeholder * Added handleCookieValidate(), postCookieValidate() * show validation only if enbled, add processing message for immediate feedback Co-authored-by: simon <simobilleter@gmail.com>	2022-05-04 17:07:01 +07:00
simon	6b3ff009da	extend cookie functionality, #build changes: - integrate watch later and liked videos playlist - merges sponsorblock state issue #236 - lots of bug fixes	2022-05-03 20:07:45 +07:00
simon	fcac10a6ce	add cookie documentation	2022-05-03 18:17:36 +07:00
simon	1613b71942	hide cookie after rescan and download process	2022-05-03 17:32:32 +07:00
simon	83beb53860	simplify _add_single to call update_status in PendingInteract directly	2022-05-02 21:38:03 +07:00
simon	8a4c50779a	standardize prints for PostData mapper	2022-05-02 18:39:54 +07:00
simon	ca5b00a373	refresh for PendingInteract delete to avoid race condition, #217	2022-05-02 18:20:56 +07:00
simon	34a1fe9e8e	fix thumb re-embed task, #231	2022-05-02 17:38:20 +07:00
simon	34c18e75f5	add LL and WL as valid playlists with cookie	2022-05-02 11:30:38 +07:00
simon	6fbac12314	fix channel_validate in PlaylistSubscription, #223	2022-05-02 11:27:50 +07:00
Nathan DeTar	c4107fc370	Fix to prevent holding onto SB info. (#236 )	2022-05-02 10:41:42 +07:00
simon	ca3ea20283	add socket_timeout when passing check_formats to yt-dlp	2022-05-02 09:48:52 +07:00
simon	8f72c5f42c	implement cookie import, #build Changed: - fix arm64 ffmpeg issue - added cookie import - use cookie for all yt-dlp calls - API: add cookie validation view	2022-04-30 19:34:10 +07:00
simon	14d85e83e6	move ffmpeg install to final container, #234	2022-04-30 19:33:11 +07:00
simon	cd139dfc1c	API: add cookie validation view	2022-04-30 19:13:49 +07:00
simon	bc7d90f1f4	raise FileNotFoundError when trying to use unavailable cookie	2022-04-30 19:09:19 +07:00
simon	3a21690309	implement post_process_updated for settings, import cookie	2022-04-30 18:35:04 +07:00
simon	487c81d50b	fix FileNotFoundError in cookie hide	2022-04-30 18:34:28 +07:00
simon	088e87bccf	add cookiefile to PendingList and VideoDownloader	2022-04-30 17:27:57 +07:00
simon	6cc5fd8890	add cookiefile to yt_obs in YouTubeItem baseclass	2022-04-30 16:40:36 +07:00
simon	4e3d71e0e3	simplify, un-userspaced	2022-04-30 16:38:23 +07:00
simon	9b107b9940	implement cookie validator	2022-04-30 13:05:01 +07:00
simon	43eec5aac0	move CookieHandler to separate module	2022-04-30 12:05:41 +07:00
simon	430fdb6f1c	add cookie import to frontend	2022-04-29 18:38:43 +07:00
simon	1fa26cdc44	added basic cookie import functionality	2022-04-23 21:59:59 +07:00
simon	fa9d6df406	api extension, #build changed: - add localhost to allowed hosts, flag to disable cors - API: pagination - API: sort and filter download list - API: add task view	2022-04-23 20:53:51 +07:00
simon	eb7313fe6b	API: add run task view	2022-04-23 20:50:38 +07:00
simon	71b3654942	add localhost:3000 to allowed	2022-04-23 20:17:31 +07:00
simon	3f99f7edff	add localhost to allowed origin, optional cors disable	2022-04-23 20:16:28 +07:00
simon	b76f38e0bc	API: fix downloads list sort	2022-04-21 05:45:55 +07:00
simon	1477370376	init data instead of class attribute	2022-04-20 22:51:30 +07:00
simon	04fc6ed26a	API: add pagination	2022-04-20 22:43:07 +07:00
simon	7305216485	add link to ES documentation for disk usage	2022-04-19 08:07:47 +07:00
simon	3147df20da	skip subtitle segments without duration, take 2	2022-04-18 11:52:13 +07:00
simon	d086f63861	API: sort and query filter download view, delete by filter	2022-04-17 20:10:49 +07:00
simon	40bb3e880e	API: implement status update and delete of item in queue	2022-04-17 19:15:40 +07:00
simon	251e98cfa3	add channel-video playlist-video api, #build Changed: - Added /api/channel/channel-id/video/ - Added /api/playlist/playlist-id/video/	2022-04-17 10:08:45 +07:00
simon	eb6d6be3b9	handle 404 in channel-video and playlist-video api view	2022-04-17 10:08:24 +07:00
simon	b8ca324aaf	add playlist-video and channel-video api views	2022-04-17 09:58:18 +07:00
simon	7d45d23767	process ta_download search results	2022-04-17 05:21:35 +07:00
simon	9224696e33	Merge branch 'api-fix' into testing	2022-04-17 05:03:05 +07:00
simon	50f4e0e5b7	skip base64 generator, hotfix	2022-04-16 13:08:32 +07:00
simon	ef803a157a	standard api key processor for list and single views	2022-04-16 00:37:56 +07:00