tubesync/tubesync/tubesync/local_settings.py.container

import sys
from pathlib import Path
from urllib.parse import urljoin
from common.utils import getenv, parse_database_connection_string


BASE_DIR = Path(__file__).resolve().parent.parent
ROOT_DIR = Path('/')
CONFIG_BASE_DIR = ROOT_DIR / 'config'
DOWNLOADS_BASE_DIR = ROOT_DIR / 'downloads'
DJANGO_URL_PREFIX = getenv('DJANGO_URL_PREFIX').strip()
STATIC_URL = getenv('DJANGO_STATIC_URL', '/static/').strip()
if DJANGO_URL_PREFIX and STATIC_URL:
    STATIC_URL = urljoin(DJANGO_URL_PREFIX, STATIC_URL[1:])


# This is not ever meant to be a public web interface so this isn't too critical
SECRET_KEY = getenv('DJANGO_SECRET_KEY', 'tubesync-django-secret')


ALLOWED_HOSTS_STR = getenv('TUBESYNC_HOSTS', '*')
ALLOWED_HOSTS = ALLOWED_HOSTS_STR.split(',')
DEBUG_STR = getenv('TUBESYNC_DEBUG', False)
DEBUG = True if 'true' == DEBUG_STR.strip().lower() else False
FORCE_SCRIPT_NAME = getenv('DJANGO_FORCE_SCRIPT_NAME', DJANGO_URL_PREFIX)


database_dict = {}
database_connection_env = getenv('DATABASE_CONNECTION')
if database_connection_env:
    database_dict = parse_database_connection_string(database_connection_env)


if database_dict:
    print(f'Using database connection: {database_dict["DRIVER"]}://'
          f'{database_dict["USER"]}:[hidden]@{database_dict["HOST"]}:'
          f'{database_dict["PORT"]}/{database_dict["NAME"]}',
        file=sys.stdout, flush=True)
    DATABASES = {
        'default': database_dict,
    }
    DATABASE_CONNECTION_STR = (f'{database_dict["DRIVER"]} at "{database_dict["HOST"]}:'
                               f'{database_dict["PORT"]}" database '
                               f'"{database_dict["NAME"]}"')
else:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': CONFIG_BASE_DIR / 'db.sqlite3',
            "OPTIONS": {
                "transaction_mode": "IMMEDIATE",
                "init_command": """
                    PRAGMA legacy_alter_table = OFF;
                    PRAGMA auto_vacuum = INCREMENTAL;
                    PRAGMA incremental_vacuum(100);
                """,
            },
        }
    }
    DATABASE_CONNECTION_STR = f'sqlite at "{DATABASES["default"]["NAME"]}"'

    # the argument to random.expovariate(),
    # a larger value means less delay
    # with too little delay, you may see
    # more "database is locked" errors
    SQLITE_DELAY_FLOAT = 5


DEFAULT_THREADS = 1
BACKGROUND_TASK_ASYNC_THREADS = getenv('TUBESYNC_WORKERS', DEFAULT_THREADS, integer=True)
if BACKGROUND_TASK_ASYNC_THREADS > 1:
    BACKGROUND_TASK_RUN_ASYNC = True


MEDIA_ROOT = CONFIG_BASE_DIR / 'media'
DOWNLOAD_ROOT = DOWNLOADS_BASE_DIR
YOUTUBE_DL_CACHEDIR = CONFIG_BASE_DIR / 'cache/yt-dlp'
YOUTUBE_DL_TEMPDIR = DOWNLOAD_ROOT / 'cache'
COOKIES_FILE = CONFIG_BASE_DIR / 'cookies.txt'


HEALTHCHECK_FIREWALL_STR = getenv('TUBESYNC_HEALTHCHECK_FIREWALL', True)
HEALTHCHECK_FIREWALL = ( 'true' == HEALTHCHECK_FIREWALL_STR.strip().lower() )
HEALTHCHECK_ALLOWED_IPS_STR = getenv('TUBESYNC_HEALTHCHECK_ALLOWED_IPS', '127.0.0.1')
HEALTHCHECK_ALLOWED_IPS = HEALTHCHECK_ALLOWED_IPS_STR.split(',')


BASICAUTH_USERNAME = getenv('HTTP_USER').strip()
BASICAUTH_PASSWORD = getenv('HTTP_PASS').strip()
if BASICAUTH_USERNAME and BASICAUTH_PASSWORD:
    BASICAUTH_DISABLE = False
    BASICAUTH_USERS = {
        BASICAUTH_USERNAME: BASICAUTH_PASSWORD,
    }
else:
    BASICAUTH_DISABLE = True
    BASICAUTH_USERS = {}


SOURCE_DOWNLOAD_DIRECTORY_PREFIX_STR = getenv('TUBESYNC_DIRECTORY_PREFIX', True)
SOURCE_DOWNLOAD_DIRECTORY_PREFIX = ( 'true' == SOURCE_DOWNLOAD_DIRECTORY_PREFIX_STR.strip().lower() )


SHRINK_NEW_MEDIA_METADATA_STR = getenv('TUBESYNC_SHRINK_NEW', False)
SHRINK_NEW_MEDIA_METADATA = ( 'true' == SHRINK_NEW_MEDIA_METADATA_STR.strip().lower() )
SHRINK_OLD_MEDIA_METADATA_STR = getenv('TUBESYNC_SHRINK_OLD', False)
SHRINK_OLD_MEDIA_METADATA = ( 'true' == SHRINK_OLD_MEDIA_METADATA_STR.strip().lower() )


# TUBESYNC_RENAME_ALL_SOURCES: True or False
RENAME_ALL_SOURCES_STR = getenv('TUBESYNC_RENAME_ALL_SOURCES', False)
RENAME_ALL_SOURCES = ( 'true' == RENAME_ALL_SOURCES_STR.strip().lower() )
# TUBESYNC_RENAME_SOURCES: A comma-separated list of Source directories
RENAME_SOURCES_STR = getenv('TUBESYNC_RENAME_SOURCES')
RENAME_SOURCES = RENAME_SOURCES_STR.split(',') if RENAME_SOURCES_STR else None


VIDEO_HEIGHT_CUTOFF = getenv("TUBESYNC_VIDEO_HEIGHT_CUTOFF", 240, integer=True)


# ensure that the current directory exists
if not YOUTUBE_DL_CACHEDIR.is_dir():
    YOUTUBE_DL_CACHEDIR.mkdir(parents=True)
# rename any old yt_dlp cache directories to the current directory
old_youtube_cache_dirs = list(YOUTUBE_DL_CACHEDIR.parent.glob('youtube-*'))
old_youtube_cache_dirs.extend(list(YOUTUBE_DL_CACHEDIR.parent.glob('youtube/youtube-*')))
for cache_dir in old_youtube_cache_dirs:
    cache_dir.rename(YOUTUBE_DL_CACHEDIR / cache_dir.name)
# try to remove the old, hopefully empty, directory
empty_old_youtube_dir = YOUTUBE_DL_CACHEDIR.parent / 'youtube'
if empty_old_youtube_dir.is_dir():
    try:
        empty_old_youtube_dir.rmdir()
    except:
        pass