You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
729 lines
28 KiB
729 lines
28 KiB
# -*- coding: utf-8 -*-
|
|
import ast
|
|
import atexit
|
|
import json
|
|
import logging
|
|
import os
|
|
import time
|
|
from datetime import datetime
|
|
|
|
from dogpile.cache import make_region
|
|
from peewee import Model, AutoField, TextField, IntegerField, ForeignKeyField, BlobField, BooleanField, BigIntegerField, \
|
|
DateTimeField, OperationalError, PostgresqlDatabase
|
|
from playhouse.migrate import PostgresqlMigrator
|
|
from playhouse.migrate import SqliteMigrator, migrate
|
|
from playhouse.shortcuts import ThreadSafeDatabaseMetadata, ReconnectMixin
|
|
from playhouse.sqlite_ext import RowIDField
|
|
from playhouse.sqliteq import SqliteQueueDatabase
|
|
|
|
from utilities.path_mappings import path_mappings
|
|
from .config import settings, get_array_from
|
|
from .get_args import args
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
postgresql = settings.postgresql.getboolean('enabled')
|
|
|
|
region = make_region().configure('dogpile.cache.memory')
|
|
|
|
if postgresql:
|
|
class ReconnectPostgresqlDatabase(ReconnectMixin, PostgresqlDatabase):
|
|
reconnect_errors = (
|
|
(OperationalError, 'server closed the connection unexpectedly'),
|
|
)
|
|
|
|
|
|
logger.debug(
|
|
f"Connecting to PostgreSQL database: {settings.postgresql.host}:{settings.postgresql.port}/{settings.postgresql.database}")
|
|
database = ReconnectPostgresqlDatabase(settings.postgresql.database,
|
|
user=settings.postgresql.username,
|
|
password=settings.postgresql.password,
|
|
host=settings.postgresql.host,
|
|
port=settings.postgresql.port,
|
|
autocommit=True,
|
|
autorollback=True,
|
|
autoconnect=True,
|
|
)
|
|
migrator = PostgresqlMigrator(database)
|
|
else:
|
|
db_path = os.path.join(args.config_dir, 'db', 'bazarr.db')
|
|
logger.debug(f"Connecting to SQLite database: {db_path}")
|
|
database = SqliteQueueDatabase(db_path,
|
|
use_gevent=False,
|
|
autostart=True,
|
|
queue_max_size=256)
|
|
migrator = SqliteMigrator(database)
|
|
|
|
|
|
@atexit.register
|
|
def _stop_worker_threads():
|
|
if not postgresql:
|
|
database.stop()
|
|
|
|
|
|
class UnknownField(object):
|
|
def __init__(self, *_, **__): pass
|
|
|
|
|
|
class BaseModel(Model):
|
|
class Meta:
|
|
database = database
|
|
model_metadata_class = ThreadSafeDatabaseMetadata
|
|
|
|
|
|
class System(BaseModel):
|
|
configured = TextField(null=True)
|
|
updated = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'system'
|
|
primary_key = False
|
|
|
|
|
|
class TableBlacklist(BaseModel):
|
|
language = TextField(null=True)
|
|
provider = TextField(null=True)
|
|
sonarr_episode_id = IntegerField(null=True)
|
|
sonarr_series_id = IntegerField(null=True)
|
|
subs_id = TextField(null=True)
|
|
timestamp = DateTimeField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_blacklist'
|
|
primary_key = False
|
|
|
|
|
|
class TableBlacklistMovie(BaseModel):
|
|
language = TextField(null=True)
|
|
provider = TextField(null=True)
|
|
radarr_id = IntegerField(null=True)
|
|
subs_id = TextField(null=True)
|
|
timestamp = DateTimeField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_blacklist_movie'
|
|
primary_key = False
|
|
|
|
|
|
class TableEpisodes(BaseModel):
|
|
rowid = RowIDField()
|
|
audio_codec = TextField(null=True)
|
|
audio_language = TextField(null=True)
|
|
episode = IntegerField()
|
|
episode_file_id = IntegerField(null=True)
|
|
failedAttempts = TextField(null=True)
|
|
ffprobe_cache = BlobField(null=True)
|
|
file_size = BigIntegerField(default=0, null=True)
|
|
format = TextField(null=True)
|
|
missing_subtitles = TextField(null=True)
|
|
monitored = TextField(null=True)
|
|
path = TextField()
|
|
resolution = TextField(null=True)
|
|
sceneName = TextField(null=True)
|
|
season = IntegerField()
|
|
sonarrEpisodeId = IntegerField(unique=True)
|
|
sonarrSeriesId = IntegerField()
|
|
subtitles = TextField(null=True)
|
|
title = TextField()
|
|
video_codec = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_episodes'
|
|
primary_key = False
|
|
|
|
|
|
class TableHistory(BaseModel):
|
|
action = IntegerField()
|
|
description = TextField()
|
|
id = AutoField()
|
|
language = TextField(null=True)
|
|
provider = TextField(null=True)
|
|
score = IntegerField(null=True)
|
|
sonarrEpisodeId = IntegerField()
|
|
sonarrSeriesId = IntegerField()
|
|
subs_id = TextField(null=True)
|
|
subtitles_path = TextField(null=True)
|
|
timestamp = DateTimeField()
|
|
video_path = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_history'
|
|
|
|
|
|
class TableHistoryMovie(BaseModel):
|
|
action = IntegerField()
|
|
description = TextField()
|
|
id = AutoField()
|
|
language = TextField(null=True)
|
|
provider = TextField(null=True)
|
|
radarrId = IntegerField()
|
|
score = IntegerField(null=True)
|
|
subs_id = TextField(null=True)
|
|
subtitles_path = TextField(null=True)
|
|
timestamp = DateTimeField()
|
|
video_path = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_history_movie'
|
|
|
|
|
|
class TableLanguagesProfiles(BaseModel):
|
|
cutoff = IntegerField(null=True)
|
|
originalFormat = BooleanField(null=True)
|
|
items = TextField()
|
|
name = TextField()
|
|
profileId = AutoField()
|
|
mustContain = TextField(null=True)
|
|
mustNotContain = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_languages_profiles'
|
|
|
|
|
|
class TableMovies(BaseModel):
|
|
rowid = RowIDField()
|
|
alternativeTitles = TextField(null=True)
|
|
audio_codec = TextField(null=True)
|
|
audio_language = TextField(null=True)
|
|
failedAttempts = TextField(null=True)
|
|
fanart = TextField(null=True)
|
|
ffprobe_cache = BlobField(null=True)
|
|
file_size = BigIntegerField(default=0, null=True)
|
|
format = TextField(null=True)
|
|
imdbId = TextField(null=True)
|
|
missing_subtitles = TextField(null=True)
|
|
monitored = TextField(null=True)
|
|
movie_file_id = IntegerField(null=True)
|
|
overview = TextField(null=True)
|
|
path = TextField(unique=True)
|
|
poster = TextField(null=True)
|
|
profileId = IntegerField(null=True)
|
|
radarrId = IntegerField(unique=True)
|
|
resolution = TextField(null=True)
|
|
sceneName = TextField(null=True)
|
|
sortTitle = TextField(null=True)
|
|
subtitles = TextField(null=True)
|
|
tags = TextField(null=True)
|
|
title = TextField()
|
|
tmdbId = TextField(unique=True)
|
|
video_codec = TextField(null=True)
|
|
year = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_movies'
|
|
|
|
|
|
class TableMoviesRootfolder(BaseModel):
|
|
accessible = IntegerField(null=True)
|
|
error = TextField(null=True)
|
|
id = IntegerField(null=True)
|
|
path = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_movies_rootfolder'
|
|
primary_key = False
|
|
|
|
|
|
class TableSettingsLanguages(BaseModel):
|
|
code2 = TextField(null=True)
|
|
code3 = TextField(primary_key=True)
|
|
code3b = TextField(null=True)
|
|
enabled = IntegerField(null=True)
|
|
name = TextField()
|
|
|
|
class Meta:
|
|
table_name = 'table_settings_languages'
|
|
|
|
|
|
class TableSettingsNotifier(BaseModel):
|
|
enabled = IntegerField(null=True)
|
|
name = TextField(null=True, primary_key=True)
|
|
url = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_settings_notifier'
|
|
|
|
|
|
class TableShows(BaseModel):
|
|
alternativeTitles = TextField(null=True)
|
|
audio_language = TextField(null=True)
|
|
fanart = TextField(null=True)
|
|
imdbId = TextField(default='""', null=True)
|
|
monitored = TextField(null=True)
|
|
overview = TextField(null=True)
|
|
path = TextField(unique=True)
|
|
poster = TextField(null=True)
|
|
profileId = IntegerField(null=True)
|
|
seriesType = TextField(null=True)
|
|
sonarrSeriesId = IntegerField(unique=True)
|
|
sortTitle = TextField(null=True)
|
|
tags = TextField(null=True)
|
|
title = TextField()
|
|
tvdbId = AutoField()
|
|
year = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_shows'
|
|
|
|
|
|
class TableShowsRootfolder(BaseModel):
|
|
accessible = IntegerField(null=True)
|
|
error = TextField(null=True)
|
|
id = IntegerField(null=True)
|
|
path = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_shows_rootfolder'
|
|
primary_key = False
|
|
|
|
|
|
class TableCustomScoreProfiles(BaseModel):
|
|
id = AutoField()
|
|
name = TextField(null=True)
|
|
media = TextField(null=True)
|
|
score = IntegerField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_custom_score_profiles'
|
|
|
|
|
|
class TableCustomScoreProfileConditions(BaseModel):
|
|
profile_id = ForeignKeyField(TableCustomScoreProfiles, to_field="id")
|
|
type = TextField(null=True) # provider, uploader, regex, etc
|
|
value = TextField(null=True) # opensubtitles, jane_doe, [a-z], etc
|
|
required = BooleanField(default=False)
|
|
negate = BooleanField(default=False)
|
|
|
|
class Meta:
|
|
table_name = 'table_custom_score_profile_conditions'
|
|
|
|
|
|
class TableAnnouncements(BaseModel):
|
|
timestamp = DateTimeField()
|
|
hash = TextField(null=True, unique=True)
|
|
text = TextField(null=True)
|
|
|
|
class Meta:
|
|
table_name = 'table_announcements'
|
|
|
|
|
|
def init_db():
|
|
# Create tables if they don't exists.
|
|
database.create_tables([System,
|
|
TableBlacklist,
|
|
TableBlacklistMovie,
|
|
TableEpisodes,
|
|
TableHistory,
|
|
TableHistoryMovie,
|
|
TableLanguagesProfiles,
|
|
TableMovies,
|
|
TableMoviesRootfolder,
|
|
TableSettingsLanguages,
|
|
TableSettingsNotifier,
|
|
TableShows,
|
|
TableShowsRootfolder,
|
|
TableCustomScoreProfiles,
|
|
TableCustomScoreProfileConditions,
|
|
TableAnnouncements])
|
|
|
|
# add the system table single row if it's not existing
|
|
# we must retry until the tables are created
|
|
tables_created = False
|
|
while not tables_created:
|
|
try:
|
|
if not System.select().count():
|
|
System.insert({System.configured: '0', System.updated: '0'}).execute()
|
|
except Exception:
|
|
time.sleep(0.1)
|
|
else:
|
|
tables_created = True
|
|
|
|
|
|
def migrate_db():
|
|
table_shows = [t.name for t in database.get_columns('table_shows')]
|
|
table_episodes = [t.name for t in database.get_columns('table_episodes')]
|
|
table_movies = [t.name for t in database.get_columns('table_movies')]
|
|
table_history = [t.name for t in database.get_columns('table_history')]
|
|
table_history_movie = [t.name for t in database.get_columns('table_history_movie')]
|
|
table_languages_profiles = [t.name for t in database.get_columns('table_languages_profiles')]
|
|
if "year" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'year', TextField(null=True)))
|
|
if "alternativeTitle" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'alternativeTitle', TextField(null=True)))
|
|
if "tags" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'tags', TextField(default='[]', null=True)))
|
|
if "seriesType" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'seriesType', TextField(default='""', null=True)))
|
|
if "imdbId" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'imdbId', TextField(default='""', null=True)))
|
|
if "profileId" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'profileId', IntegerField(null=True)))
|
|
if "profileId" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'profileId', IntegerField(null=True)))
|
|
if "monitored" not in table_shows:
|
|
migrate(migrator.add_column('table_shows', 'monitored', TextField(null=True)))
|
|
|
|
if "format" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'format', TextField(null=True)))
|
|
if "resolution" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'resolution', TextField(null=True)))
|
|
if "video_codec" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'video_codec', TextField(null=True)))
|
|
if "audio_codec" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'audio_codec', TextField(null=True)))
|
|
if "episode_file_id" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'episode_file_id', IntegerField(null=True)))
|
|
if "audio_language" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'audio_language', TextField(null=True)))
|
|
if "file_size" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'file_size', BigIntegerField(default=0, null=True)))
|
|
if "ffprobe_cache" not in table_episodes:
|
|
migrate(migrator.add_column('table_episodes', 'ffprobe_cache', BlobField(null=True)))
|
|
|
|
if "sortTitle" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'sortTitle', TextField(null=True)))
|
|
if "year" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'year', TextField(null=True)))
|
|
if "alternativeTitles" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'alternativeTitles', TextField(null=True)))
|
|
if "format" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'format', TextField(null=True)))
|
|
if "resolution" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'resolution', TextField(null=True)))
|
|
if "video_codec" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'video_codec', TextField(null=True)))
|
|
if "audio_codec" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'audio_codec', TextField(null=True)))
|
|
if "imdbId" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'imdbId', TextField(null=True)))
|
|
if "movie_file_id" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'movie_file_id', IntegerField(null=True)))
|
|
if "tags" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'tags', TextField(default='[]', null=True)))
|
|
if "profileId" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'profileId', IntegerField(null=True)))
|
|
if "file_size" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'file_size', BigIntegerField(default=0, null=True)))
|
|
if "ffprobe_cache" not in table_movies:
|
|
migrate(migrator.add_column('table_movies', 'ffprobe_cache', BlobField(null=True)))
|
|
|
|
if "video_path" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'video_path', TextField(null=True)))
|
|
if "language" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'language', TextField(null=True)))
|
|
if "provider" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'provider', TextField(null=True)))
|
|
if "score" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'score', TextField(null=True)))
|
|
if "subs_id" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'subs_id', TextField(null=True)))
|
|
if "subtitles_path" not in table_history:
|
|
migrate(migrator.add_column('table_history', 'subtitles_path', TextField(null=True)))
|
|
|
|
if "video_path" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'video_path', TextField(null=True)))
|
|
if "language" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'language', TextField(null=True)))
|
|
if "provider" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'provider', TextField(null=True)))
|
|
if "score" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'score', TextField(null=True)))
|
|
if "subs_id" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'subs_id', TextField(null=True)))
|
|
if "subtitles_path" not in table_history_movie:
|
|
migrate(migrator.add_column('table_history_movie', 'subtitles_path', TextField(null=True)))
|
|
|
|
if "mustContain" not in table_languages_profiles:
|
|
migrate(migrator.add_column('table_languages_profiles', 'mustContain', TextField(null=True)))
|
|
if "mustNotContain" not in table_languages_profiles:
|
|
migrate(migrator.add_column('table_languages_profiles', 'mustNotContain', TextField(null=True)))
|
|
if "originalFormat" not in table_languages_profiles:
|
|
migrate(migrator.add_column('table_languages_profiles', 'originalFormat', BooleanField(null=True)))
|
|
|
|
if "languages" in table_shows:
|
|
migrate(migrator.drop_column('table_shows', 'languages'))
|
|
if "hearing_impaired" in table_shows:
|
|
migrate(migrator.drop_column('table_shows', 'hearing_impaired'))
|
|
|
|
if "languages" in table_movies:
|
|
migrate(migrator.drop_column('table_movies', 'languages'))
|
|
if "hearing_impaired" in table_movies:
|
|
migrate(migrator.drop_column('table_movies', 'hearing_impaired'))
|
|
if not any(
|
|
x
|
|
for x in database.get_columns('table_blacklist')
|
|
if x.name == "timestamp" and x.data_type in ["DATETIME", "timestamp without time zone"]
|
|
):
|
|
migrate(migrator.alter_column_type('table_blacklist', 'timestamp', DateTimeField(default=datetime.now)))
|
|
update = TableBlacklist.select()
|
|
for item in update:
|
|
item.update({"timestamp": datetime.fromtimestamp(int(item.timestamp))}).execute()
|
|
|
|
if not any(
|
|
x
|
|
for x in database.get_columns('table_blacklist_movie')
|
|
if x.name == "timestamp" and x.data_type in ["DATETIME", "timestamp without time zone"]
|
|
):
|
|
migrate(migrator.alter_column_type('table_blacklist_movie', 'timestamp', DateTimeField(default=datetime.now)))
|
|
update = TableBlacklistMovie.select()
|
|
for item in update:
|
|
item.update({"timestamp": datetime.fromtimestamp(int(item.timestamp))}).execute()
|
|
|
|
if not any(
|
|
x for x in database.get_columns('table_history') if x.name == "score" and x.data_type.lower() == "integer"):
|
|
migrate(migrator.alter_column_type('table_history', 'score', IntegerField(null=True)))
|
|
if not any(
|
|
x
|
|
for x in database.get_columns('table_history')
|
|
if x.name == "timestamp" and x.data_type in ["DATETIME", "timestamp without time zone"]
|
|
):
|
|
migrate(migrator.alter_column_type('table_history', 'timestamp', DateTimeField(default=datetime.now)))
|
|
update = TableHistory.select()
|
|
list_to_update = []
|
|
for i, item in enumerate(update):
|
|
item.timestamp = datetime.fromtimestamp(int(item.timestamp))
|
|
list_to_update.append(item)
|
|
if i % 100 == 0:
|
|
TableHistory.bulk_update(list_to_update, fields=[TableHistory.timestamp])
|
|
list_to_update = []
|
|
if list_to_update:
|
|
TableHistory.bulk_update(list_to_update, fields=[TableHistory.timestamp])
|
|
|
|
if not any(x for x in database.get_columns('table_history_movie') if
|
|
x.name == "score" and x.data_type.lower() == "integer"):
|
|
migrate(migrator.alter_column_type('table_history_movie', 'score', IntegerField(null=True)))
|
|
if not any(
|
|
x
|
|
for x in database.get_columns('table_history_movie')
|
|
if x.name == "timestamp" and x.data_type in ["DATETIME", "timestamp without time zone"]
|
|
):
|
|
migrate(migrator.alter_column_type('table_history_movie', 'timestamp', DateTimeField(default=datetime.now)))
|
|
update = TableHistoryMovie.select()
|
|
list_to_update = []
|
|
for i, item in enumerate(update):
|
|
item.timestamp = datetime.fromtimestamp(int(item.timestamp))
|
|
list_to_update.append(item)
|
|
if i % 100 == 0:
|
|
TableHistoryMovie.bulk_update(list_to_update, fields=[TableHistoryMovie.timestamp])
|
|
list_to_update = []
|
|
if list_to_update:
|
|
TableHistoryMovie.bulk_update(list_to_update, fields=[TableHistoryMovie.timestamp])
|
|
# if not any(x for x in database.get_columns('table_movies') if x.name == "monitored" and x.data_type == "BOOLEAN"):
|
|
# migrate(migrator.alter_column_type('table_movies', 'monitored', BooleanField(null=True)))
|
|
|
|
if database.get_columns('table_settings_providers'):
|
|
database.execute_sql('drop table if exists table_settings_providers;')
|
|
|
|
if "alternateTitles" in table_shows:
|
|
migrate(migrator.rename_column('table_shows', 'alternateTitles', "alternativeTitles"))
|
|
|
|
if "scene_name" in table_episodes:
|
|
migrate(migrator.rename_column('table_episodes', 'scene_name', "sceneName"))
|
|
|
|
|
|
class SqliteDictPathMapper:
|
|
def __init__(self):
|
|
pass
|
|
|
|
@staticmethod
|
|
def path_replace(values_dict):
|
|
if type(values_dict) is list:
|
|
for item in values_dict:
|
|
item['path'] = path_mappings.path_replace(item['path'])
|
|
elif type(values_dict) is dict:
|
|
values_dict['path'] = path_mappings.path_replace(values_dict['path'])
|
|
else:
|
|
return path_mappings.path_replace(values_dict)
|
|
|
|
@staticmethod
|
|
def path_replace_movie(values_dict):
|
|
if type(values_dict) is list:
|
|
for item in values_dict:
|
|
item['path'] = path_mappings.path_replace_movie(item['path'])
|
|
elif type(values_dict) is dict:
|
|
values_dict['path'] = path_mappings.path_replace_movie(values_dict['path'])
|
|
else:
|
|
return path_mappings.path_replace_movie(values_dict)
|
|
|
|
|
|
dict_mapper = SqliteDictPathMapper()
|
|
|
|
|
|
def get_exclusion_clause(exclusion_type):
|
|
where_clause = []
|
|
if exclusion_type == 'series':
|
|
tagsList = ast.literal_eval(settings.sonarr.excluded_tags)
|
|
for tag in tagsList:
|
|
where_clause.append(~(TableShows.tags.contains("\'" + tag + "\'")))
|
|
else:
|
|
tagsList = ast.literal_eval(settings.radarr.excluded_tags)
|
|
for tag in tagsList:
|
|
where_clause.append(~(TableMovies.tags.contains("\'" + tag + "\'")))
|
|
|
|
if exclusion_type == 'series':
|
|
monitoredOnly = settings.sonarr.getboolean('only_monitored')
|
|
if monitoredOnly:
|
|
where_clause.append((TableEpisodes.monitored == True)) # noqa E712
|
|
where_clause.append((TableShows.monitored == True)) # noqa E712
|
|
else:
|
|
monitoredOnly = settings.radarr.getboolean('only_monitored')
|
|
if monitoredOnly:
|
|
where_clause.append((TableMovies.monitored == True)) # noqa E712
|
|
|
|
if exclusion_type == 'series':
|
|
typesList = get_array_from(settings.sonarr.excluded_series_types)
|
|
for item in typesList:
|
|
where_clause.append((TableShows.seriesType != item))
|
|
|
|
exclude_season_zero = settings.sonarr.getboolean('exclude_season_zero')
|
|
if exclude_season_zero:
|
|
where_clause.append((TableEpisodes.season != 0))
|
|
|
|
return where_clause
|
|
|
|
|
|
@region.cache_on_arguments()
|
|
def update_profile_id_list():
|
|
profile_id_list = TableLanguagesProfiles.select(TableLanguagesProfiles.profileId,
|
|
TableLanguagesProfiles.name,
|
|
TableLanguagesProfiles.cutoff,
|
|
TableLanguagesProfiles.items,
|
|
TableLanguagesProfiles.mustContain,
|
|
TableLanguagesProfiles.mustNotContain,
|
|
TableLanguagesProfiles.originalFormat).dicts()
|
|
profile_id_list = list(profile_id_list)
|
|
for profile in profile_id_list:
|
|
profile['items'] = json.loads(profile['items'])
|
|
profile['mustContain'] = ast.literal_eval(profile['mustContain']) if profile['mustContain'] else []
|
|
profile['mustNotContain'] = ast.literal_eval(profile['mustNotContain']) if profile['mustNotContain'] else []
|
|
|
|
return profile_id_list
|
|
|
|
|
|
def get_profiles_list(profile_id=None):
|
|
profile_id_list = update_profile_id_list()
|
|
|
|
if profile_id and profile_id != 'null':
|
|
for profile in profile_id_list:
|
|
if profile['profileId'] == profile_id:
|
|
return profile
|
|
else:
|
|
return profile_id_list
|
|
|
|
|
|
def get_desired_languages(profile_id):
|
|
languages = []
|
|
profile_id_list = update_profile_id_list()
|
|
|
|
if profile_id and profile_id != 'null':
|
|
for profile in profile_id_list:
|
|
profileId, name, cutoff, items, mustContain, mustNotContain, originalFormat = profile.values()
|
|
try:
|
|
profile_id_int = int(profile_id)
|
|
except ValueError:
|
|
continue
|
|
else:
|
|
if profileId == profile_id_int:
|
|
languages = [x['language'] for x in items]
|
|
break
|
|
|
|
return languages
|
|
|
|
|
|
def get_profile_id_name(profile_id):
|
|
name_from_id = None
|
|
profile_id_list = update_profile_id_list()
|
|
|
|
if profile_id and profile_id != 'null':
|
|
for profile in profile_id_list:
|
|
profileId, name, cutoff, items, mustContain, mustNotContain, originalFormat = profile.values()
|
|
if profileId == int(profile_id):
|
|
name_from_id = name
|
|
break
|
|
|
|
return name_from_id
|
|
|
|
|
|
def get_profile_cutoff(profile_id):
|
|
cutoff_language = None
|
|
profile_id_list = update_profile_id_list()
|
|
|
|
if profile_id and profile_id != 'null':
|
|
cutoff_language = []
|
|
for profile in profile_id_list:
|
|
profileId, name, cutoff, items, mustContain, mustNotContain, originalFormat = profile.values()
|
|
if cutoff:
|
|
if profileId == int(profile_id):
|
|
for item in items:
|
|
if item['id'] == cutoff:
|
|
return [item]
|
|
elif cutoff == 65535:
|
|
cutoff_language.append(item)
|
|
|
|
if not len(cutoff_language):
|
|
cutoff_language = None
|
|
|
|
return cutoff_language
|
|
|
|
|
|
def get_audio_profile_languages(audio_languages_list_str):
|
|
from languages.get_languages import alpha2_from_language, alpha3_from_language, language_from_alpha2
|
|
audio_languages = []
|
|
|
|
und_default_language = language_from_alpha2(settings.general.default_und_audio_lang)
|
|
|
|
try:
|
|
audio_languages_list = ast.literal_eval(audio_languages_list_str or '[]')
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
for language in audio_languages_list:
|
|
if language:
|
|
audio_languages.append(
|
|
{"name": language,
|
|
"code2": alpha2_from_language(language) or None,
|
|
"code3": alpha3_from_language(language) or None}
|
|
)
|
|
else:
|
|
if und_default_language:
|
|
logging.debug(f"Undefined language audio track treated as {und_default_language}")
|
|
audio_languages.append(
|
|
{"name": und_default_language,
|
|
"code2": alpha2_from_language(und_default_language) or None,
|
|
"code3": alpha3_from_language(und_default_language) or None}
|
|
)
|
|
|
|
return audio_languages
|
|
|
|
|
|
def get_profile_id(series_id=None, episode_id=None, movie_id=None):
|
|
if series_id:
|
|
data = TableShows.select(TableShows.profileId) \
|
|
.where(TableShows.sonarrSeriesId == series_id) \
|
|
.get_or_none()
|
|
if data:
|
|
return data.profileId
|
|
elif episode_id:
|
|
data = TableShows.select(TableShows.profileId) \
|
|
.join(TableEpisodes, on=(TableShows.sonarrSeriesId == TableEpisodes.sonarrSeriesId)) \
|
|
.where(TableEpisodes.sonarrEpisodeId == episode_id) \
|
|
.get_or_none()
|
|
if data:
|
|
return data.profileId
|
|
|
|
elif movie_id:
|
|
data = TableMovies.select(TableMovies.profileId) \
|
|
.where(TableMovies.radarrId == movie_id) \
|
|
.get_or_none()
|
|
if data:
|
|
return data.profileId
|
|
|
|
return None
|
|
|
|
|
|
def convert_list_to_clause(arr: list):
|
|
if isinstance(arr, list):
|
|
return f"({','.join(str(x) for x in arr)})"
|
|
else:
|
|
return ""
|