__init__.py

# ##############################################################################
#  Author: echel0n <[email protected]>
#  URL: https://sickrage.ca/
#  Git: https://git.sickrage.ca/SiCKRAGE/sickrage.git
#  -
#  This file is part of SiCKRAGE.
#  -
#  SiCKRAGE is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#  -
#  SiCKRAGE is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#  -
#  You should have received a copy of the GNU General Public License
#  along with SiCKRAGE.  If not, see <http://www.gnu.org/licenses/>.
# ##############################################################################

import datetime
import glob
import os
import re
import shutil
import stat
import threading
import traceback

import send2trash
import sqlalchemy
from adba.aniDBAbstracter import Anime
from sqlalchemy import orm
from unidecode import unidecode

import sickrage
from sickrage.core.blackandwhitelist import BlackAndWhiteList
from sickrage.core.caches.image_cache import ImageCache
from sickrage.core.common import Quality, Qualities, EpisodeStatus
from sickrage.core.databases.main import MainDB
from sickrage.core.databases.main.schemas import TVShowSchema, IMDbInfoSchema, BlacklistSchema, WhitelistSchema
from sickrage.core.enums import SeriesProviderID
from sickrage.core.exceptions import ShowNotFoundException, EpisodeNotFoundException, EpisodeDeletedException, MultipleEpisodesInDatabaseException
from sickrage.core.helpers import list_media_files, is_media_file, try_int, safe_getattr, flatten
from sickrage.core.media.util import series_image, SeriesImageType
from sickrage.core.tv.episode import TVEpisode
from sickrage.series_providers.exceptions import SeriesProviderAttributeNotFound, SeriesProviderException


class TVShowID(object):
    def __init__(self, series_id, series_provider_id):
        self.series_id = series_id
        self.series_provider_id = series_provider_id

    @property
    def slug(self):
        return f'{self.series_id}-{self.series_provider_id.value}'


class TVShow(object):
    def __init__(self, series_id, series_provider_id, lang='eng', location=''):
        self.lock = threading.Lock()
        self._episodes = {}
        self.loading_episodes = False

        with sickrage.app.main_db.session() as session:
            try:
                query = session.query(MainDB.TVShow).filter_by(series_id=series_id, series_provider_id=series_provider_id).one()
                self._data_local = query.as_dict()
            except orm.exc.NoResultFound:
                self._data_local = MainDB.TVShow().as_dict()
                self._data_local.update(**{
                    'series_id': series_id,
                    'series_provider_id': series_provider_id,
                    'lang': lang,
                    'location': location
                })

                self.load_from_series_provider()

        sickrage.app.shows.update({(self.series_id, self.series_provider_id): self})

    @property
    def slug(self):
        return f'{self.series_id}-{self.series_provider_id.value}'

    @property
    def series_id(self):
        return self._data_local['series_id']

    @series_id.setter
    def series_id(self, value):
        self._data_local['series_id'] = value

    @property
    def series_provider_id(self):
        return self._data_local['series_provider_id']

    @series_provider_id.setter
    def series_provider_id(self, value):
        self._data_local['series_provider_id'] = value

    @property
    def tvdb_id(self):
        if self.series_provider_id == SeriesProviderID.THETVDB:
            return self.series_id

    @property
    def name(self):
        return self._data_local['name']

    @name.setter
    def name(self, value):
        self._data_local['name'] = value

    @property
    def location(self):
        return self._data_local['location']

    @location.setter
    def location(self, value):
        self._data_local['location'] = value

    @property
    def network(self):
        return self._data_local['network']

    @network.setter
    def network(self, value):
        self._data_local['network'] = value

    @property
    def genre(self):
        return self._data_local['genre']

    @genre.setter
    def genre(self, value):
        self._data_local['genre'] = value

    @property
    def overview(self):
        return self._data_local['overview']

    @overview.setter
    def overview(self, value):
        self._data_local['overview'] = value

    @property
    def classification(self):
        return self._data_local['classification']

    @classification.setter
    def classification(self, value):
        self._data_local['classification'] = value

    @property
    def runtime(self):
        return self._data_local['runtime']

    @runtime.setter
    def runtime(self, value):
        self._data_local['runtime'] = value

    @property
    def quality(self):
        return self._data_local['quality']

    @quality.setter
    def quality(self, value):
        self._data_local['quality'] = value

    @property
    def airs(self):
        return self._data_local['airs']

    @airs.setter
    def airs(self, value):
        self._data_local['airs'] = value

    @property
    def status(self):
        return self._data_local['status']

    @status.setter
    def status(self, value):
        self._data_local['status'] = value

    @property
    def flatten_folders(self):
        return self._data_local['flatten_folders']

    @flatten_folders.setter
    def flatten_folders(self, value):
        self._data_local['flatten_folders'] = value

    @property
    def paused(self):
        return self._data_local['paused']

    @paused.setter
    def paused(self, value):
        self._data_local['paused'] = value

    @property
    def scene(self):
        return self._data_local['scene']

    @scene.setter
    def scene(self, value):
        self._data_local['scene'] = value

    @property
    def anime(self):
        return self._data_local['anime']

    @anime.setter
    def anime(self, value):
        self._data_local['anime'] = value

    @property
    def search_format(self):
        return self._data_local['search_format']

    @search_format.setter
    def search_format(self, value):
        self._data_local['search_format'] = value

    @property
    def subtitles(self):
        return self._data_local['subtitles']

    @subtitles.setter
    def subtitles(self, value):
        self._data_local['subtitles'] = value

    @property
    def dvd_order(self):
        return self._data_local['dvd_order']

    @dvd_order.setter
    def dvd_order(self, value):
        self._data_local['dvd_order'] = value

    @property
    def skip_downloaded(self):
        return self._data_local['skip_downloaded']

    @skip_downloaded.setter
    def skip_downloaded(self, value):
        self._data_local['skip_downloaded'] = value

    @property
    def startyear(self):
        return self._data_local['startyear']

    @startyear.setter
    def startyear(self, value):
        self._data_local['startyear'] = value

    @property
    def lang(self):
        return self._data_local['lang']

    @lang.setter
    def lang(self, value):
        self._data_local['lang'] = value

    @property
    def imdb_id(self):
        return self._data_local['imdb_id']

    @imdb_id.setter
    def imdb_id(self, value):
        self._data_local['imdb_id'] = value

    @property
    def rls_ignore_words(self):
        return self._data_local['rls_ignore_words']

    @rls_ignore_words.setter
    def rls_ignore_words(self, value):
        self._data_local['rls_ignore_words'] = value

    @property
    def rls_require_words(self):
        return self._data_local['rls_require_words']

    @rls_require_words.setter
    def rls_require_words(self, value):
        self._data_local['rls_require_words'] = value

    @property
    def default_ep_status(self):
        return self._data_local['default_ep_status']

    @default_ep_status.setter
    def default_ep_status(self, value):
        self._data_local['default_ep_status'] = value

    @property
    def sub_use_sr_metadata(self):
        return self._data_local['sub_use_sr_metadata']

    @sub_use_sr_metadata.setter
    def sub_use_sr_metadata(self, value):
        self._data_local['sub_use_sr_metadata'] = value

    @property
    def notify_list(self):
        return self._data_local['notify_list']

    @notify_list.setter
    def notify_list(self, value):
        self._data_local['notify_list'] = value

    @property
    def search_delay(self):
        return self._data_local['search_delay']

    @search_delay.setter
    def search_delay(self, value):
        self._data_local['search_delay'] = value

    @property
    def scene_exceptions(self):
        if self._data_local['scene_exceptions']:
            return list(filter(None, self._data_local['scene_exceptions'].split(',')))
        return []

    @scene_exceptions.setter
    def scene_exceptions(self, value):
        self._data_local['scene_exceptions'] = ','.join(value)

    @property
    def last_update(self):
        return self._data_local['last_update']

    @last_update.setter
    def last_update(self, value):
        self._data_local['last_update'] = value

    @property
    def last_refresh(self):
        return self._data_local['last_refresh']

    @last_refresh.setter
    def last_refresh(self, value):
        self._data_local['last_refresh'] = value

    @property
    def last_backlog_search(self):
        return self._data_local['last_backlog_search']

    @last_backlog_search.setter
    def last_backlog_search(self, value):
        self._data_local['last_backlog_search'] = value

    @property
    def last_proper_search(self):
        return self._data_local['last_proper_search']

    @last_proper_search.setter
    def last_proper_search(self, value):
        self._data_local['last_proper_search'] = value

    @property
    def last_scene_exceptions_refresh(self):
        return self._data_local['last_scene_exceptions_refresh']

    @last_scene_exceptions_refresh.setter
    def last_scene_exceptions_refresh(self, value):
        self._data_local['last_scene_exceptions_refresh'] = value

    @property
    def last_xem_refresh(self):
        return self._data_local['last_xem_refresh']

    @last_xem_refresh.setter
    def last_xem_refresh(self, value):
        self._data_local['last_xem_refresh'] = value

    @property
    def series_provider(self):
        return sickrage.app.series_providers[self.series_provider_id]

    @property
    def episodes(self):
        if not self._episodes:
            with sickrage.app.main_db.session() as session:
                for x in session.query(MainDB.TVEpisode).filter_by(series_id=self.series_id, series_provider_id=self.series_provider_id):
                    self._episodes[x.episode_id] = TVEpisode(series_id=x.series_id, series_provider_id=x.series_provider_id, season=x.season, episode=x.episode)
        return list(self._episodes.values())

    @property
    def imdb_info(self):
        with sickrage.app.main_db.session() as session:
            return session.query(MainDB.IMDbInfo).filter_by(series_id=self.series_id).one_or_none()

    @property
    def is_anime(self):
        return int(self.anime) > 0

    @property
    def airs_next(self):
        _airs_next = datetime.date.min

        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.season > 0,
                MainDB.TVEpisode.airdate >= datetime.date.today(),
                MainDB.TVEpisode.status.in_([EpisodeStatus.UNAIRED, EpisodeStatus.WANTED])
            ).order_by(
                MainDB.TVEpisode.airdate
            ).first()

            if query:
                _airs_next = query.airdate

        return _airs_next

    @property
    def airs_prev(self):
        _airs_prev = datetime.date.min

        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.season > 0,
                MainDB.TVEpisode.airdate < datetime.date.today(),
                MainDB.TVEpisode.status != EpisodeStatus.UNAIRED
            ).order_by(
                sqlalchemy.desc(MainDB.TVEpisode.airdate)
            ).first()

            if query:
                _airs_prev = query.airdate

        return _airs_prev

    @property
    def episodes_unaired(self):
        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode.season, MainDB.TVEpisode.status
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.status == EpisodeStatus.UNAIRED
            )

            if not sickrage.app.config.gui.display_show_specials:
                query = query.filter(MainDB.TVEpisode.season > 0)

        return query.count()

    @property
    def episodes_snatched(self):
        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode.season, MainDB.TVEpisode.status
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.status.in_(flatten([EpisodeStatus.composites(EpisodeStatus.SNATCHED), EpisodeStatus.composites(EpisodeStatus.SNATCHED_BEST),
                                                     EpisodeStatus.composites(EpisodeStatus.SNATCHED_PROPER)]))
            )

            if not sickrage.app.config.gui.display_show_specials:
                query = query.filter(MainDB.TVEpisode.season > 0)

        return query.count()

    @property
    def episodes_downloaded(self):
        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode.season, MainDB.TVEpisode.status
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.status.in_(flatten([EpisodeStatus.composites(EpisodeStatus.DOWNLOADED), EpisodeStatus.composites(EpisodeStatus.ARCHIVED)]))
            )

            if not sickrage.app.config.gui.display_show_specials:
                query = query.filter(MainDB.TVEpisode.season > 0)

        return query.count()

    @property
    def episodes_special(self):
        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode.season
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.season == 0
            )

        return query.count()

    @property
    def episodes_total(self):
        with sickrage.app.main_db.session() as session:
            query = session.query(
                MainDB.TVEpisode.season, MainDB.TVEpisode.status
            ).filter_by(
                series_id=self.series_id, series_provider_id=self.series_provider_id
            ).filter(
                MainDB.TVEpisode.status != EpisodeStatus.UNAIRED
            )

            if not sickrage.app.config.gui.display_show_specials:
                query = query.filter(MainDB.TVEpisode.season > 0)

        return query.count()

    @property
    def new_episodes(self):
        cur_date = datetime.date.today()
        cur_date += datetime.timedelta(days=1)
        cur_time = datetime.datetime.now(sickrage.app.tz)

        new_episodes = []
        for episode_object in self.episodes:
            if episode_object.status != EpisodeStatus.UNAIRED or episode_object.season == 0 or not episode_object.airdate > datetime.date.min:
                continue

            air_date = episode_object.airdate
            air_date += datetime.timedelta(days=episode_object.show.search_delay)
            if not cur_date >= air_date:
                continue

            if episode_object.show.airs and episode_object.show.network:
                # This is how you assure it is always converted to local time
                air_time = sickrage.app.tz_updater.parse_date_time(episode_object.airdate,
                                                                   episode_object.show.airs,
                                                                   episode_object.show.network).astimezone(sickrage.app.tz)

                # filter out any episodes that haven't started airing yet,
                # but set them to the default status while they are airing
                # so they are snatched faster
                if air_time > cur_time:
                    continue

            new_episodes += [episode_object]

        return new_episodes

    @property
    def total_size(self):
        _total_size = 0
        _related_episodes = set()
        for episode_object in self.episodes:
            [_related_episodes.add(related_episode.episode_id) for related_episode in episode_object.related_episodes]
            if episode_object.episode_id not in _related_episodes:
                _total_size += episode_object.file_size
        return _total_size

    @property
    def network_logo_name(self):
        return unidecode(self.network).lower()

    @property
    def release_groups(self):
        if self.is_anime:
            return BlackAndWhiteList(self.series_id, self.series_provider_id)

    @property
    def poster(self):
        return series_image(self.series_id, self.series_provider_id, SeriesImageType.POSTER).url

    @property
    def banner(self):
        return series_image(self.series_id, self.series_provider_id, SeriesImageType.BANNER).url

    @property
    def allowed_qualities(self):
        allowed_qualities, __ = Quality.split_quality(self.quality)
        return allowed_qualities

    @property
    def preferred_qualities(self):
        __, preferred_qualities = Quality.split_quality(self.quality)
        return preferred_qualities

    @property
    def show_queue_status(self):
        if sickrage.app.show_queue.is_being_added(self.series_id):
            return {
                'action': 'ADD',
                'message': _('This show is in the process of being downloaded - the info below is incomplete.')
            }
        elif sickrage.app.show_queue.is_being_removed(self.series_id):
            return {
                'action': 'REMOVE',
                'message': _('This show is in the process of being removed.')
            }
        elif sickrage.app.show_queue.is_being_updated(self.series_id):
            return {
                'action': 'UPDATE',
                'message': _('The information on this page is in the process of being updated.')
            }
        elif sickrage.app.show_queue.is_being_refreshed(self.series_id):
            return {
                'action': 'REFRESH',
                'message': _('The episodes below are currently being refreshed from disk')
            }
        elif sickrage.app.show_queue.is_being_subtitled(self.series_id):
            return {
                'action': 'SUBTITLE',
                'message': _('Currently downloading subtitles for this show')
            }
        elif sickrage.app.show_queue.is_queued_to_refresh(self.series_id):
            return {
                'action': 'REFRESH_QUEUE',
                'message': _('This show is queued to be refreshed.')
            }
        elif sickrage.app.show_queue.is_queued_to_update(self.series_id):
            return {
                'action': 'UPDATE_QUEUE',
                'message': _('This show is queued and awaiting an update.')
            }
        elif sickrage.app.show_queue.is_queued_to_subtitle(self.series_id):
            return {
                'action': 'SUBTITLE_QUEUE',
                'message': _('This show is queued and awaiting subtitles download.')
            }

        return {}

    @property
    def is_loading(self):
        return self.show_queue_status.get('action') == 'ADD'

    @property
    def is_removing(self):
        return self.show_queue_status.get('action') == 'REMOVE'

    @property
    def is_loading_episodes(self):
        return self.loading_episodes

    def save(self):
        with self.lock, sickrage.app.main_db.session() as session:
            sickrage.app.log.debug("{0:d}: Saving to database: {1}".format(self.series_id, self.name))

            try:
                query = session.query(MainDB.TVShow).filter_by(series_id=self.series_id, series_provider_id=self.series_provider_id).one()
                query.update(**self._data_local)
            except orm.exc.NoResultFound:
                session.add(MainDB.TVShow(**self._data_local))
            finally:
                session.commit()

    def delete(self):
        with self.lock, sickrage.app.main_db.session() as session:
            session.query(MainDB.TVShow).filter_by(series_id=self.series_id, series_provider_id=self.series_provider_id).delete()
            session.commit()

    def flush_episodes(self):
        self._episodes.clear()

    def load_from_series_provider(self, cache=True):
        sickrage.app.log.debug(str(self.series_id) + ": Loading show info from " + self.series_provider.name)

        series_provider_language = self.lang or sickrage.app.config.general.series_provider_default_language
        series_info = self.series_provider.get_series_info(self.series_id, language=series_provider_language, enable_cache=cache)
        if not series_info:
            raise SeriesProviderException

        try:
            self.name = series_info['name'].strip()
        except AttributeError:
            raise SeriesProviderAttributeNotFound("Found %s, but attribute 'name' was empty." % self.series_id)

        self.overview = safe_getattr(series_info, 'overview', self.overview)
        # self.classification = safe_getattr(series_info, 'classification', self.classification)
        self.genre = safe_getattr(series_info, 'genre', self.genre)
        self.network = safe_getattr(series_info, 'network', self.network)
        self.runtime = try_int(safe_getattr(series_info, 'runtime', self.runtime))
        self.imdb_id = safe_getattr(series_info, 'imdbId', self.imdb_id)

        try:
            self.airs = f"{safe_getattr(series_info, 'airDay')} {safe_getattr(series_info, 'airTime')}"
        except:
            self.airs = ''

        try:
            self.startyear = try_int(str(safe_getattr(series_info, 'firstAired') or datetime.date.min).split('-')[0])
        except:
            self.startyear = 0

        self.status = safe_getattr(series_info, 'status', self.status)

        self.save()

    def load_episodes_from_series_provider(self, cache=True):
        scanned_eps = {}

        self.loading_episodes = True

        sickrage.app.log.debug(str(self.series_id) + ": Loading all episodes from " + self.series_provider.name + "..")

        # flush episodes from cache so we can reload from database
        self.flush_episodes()

        series_provider_language = self.lang or sickrage.app.config.general.series_provider_default_language
        series_info = self.series_provider.get_series_info(self.series_id, language=series_provider_language, enable_cache=cache)
        if not series_info:
            self.loading_episodes = False
            raise SeriesProviderException

        for season in series_info:
            scanned_eps[season] = {}
            for episode in series_info[season]:
                # need some examples of wtf episode 0 means to decide if we want it or not
                if episode == 0:
                    continue

                try:
                    episode_obj = self.get_episode(season, episode)
                except EpisodeNotFoundException:
                    continue
                else:
                    try:
                        episode_obj.load_from_series_provider(season, episode)
                        episode_obj.save()
                    except EpisodeDeletedException:
                        sickrage.app.log.info("The episode was deleted, skipping the rest of the load")
                        continue

                scanned_eps[season][episode] = True

        # Done updating save last update date
        self.last_update = datetime.datetime.now()

        self.save()

        self.loading_episodes = False

        return scanned_eps

    def get_episode(self, season=None, episode=None, absolute_number=None, location=None, no_create=False):
        try:
            if season is None and episode is None and absolute_number is not None:
                with sickrage.app.main_db.session() as session:
                    query = session.query(MainDB.TVEpisode).filter_by(series_id=self.series_id, series_provider_id=self.series_provider_id,
                                                                      absolute_number=absolute_number).one()
                    sickrage.app.log.debug("Found episode by absolute_number %s which is S%02dE%02d" % (absolute_number, query.season, query.episode))
                    season = query.season
                    episode = query.episode

            for tv_episode in self.episodes:
                if tv_episode.season == season and tv_episode.episode == episode:
                    return tv_episode
            else:
                if no_create:
                    return None

                tv_episode = TVEpisode(series_id=self.series_id,
                                       series_provider_id=self.series_provider_id,
                                       season=season,
                                       episode=episode,
                                       location=location or '')

                self._episodes[tv_episode.episode_id] = tv_episode
                return tv_episode
        except orm.exc.MultipleResultsFound:
            if absolute_number is not None:
                sickrage.app.log.debug("Multiple entries for absolute number: " + str(absolute_number) + " in show: " + self.name + " found ")
            raise MultipleEpisodesInDatabaseException
        except orm.exc.NoResultFound:
            if absolute_number is not None:
                sickrage.app.log.debug("No entries for absolute number: " + str(absolute_number) + " in show: " + self.name + " found.")
            raise EpisodeNotFoundException

    def delete_episode(self, season, episode, full=False):
        episode_object = self.get_episode(season, episode, no_create=True)
        if not episode_object:
            return

        data = sickrage.app.notification_providers['trakt'].trakt_episode_data_generate([(episode_object.season, episode_object.episode)])
        if sickrage.app.config.trakt.enable and sickrage.app.config.trakt.sync_watchlist and data:
            sickrage.app.log.debug("Deleting episode from Trakt")
            sickrage.app.notification_providers['trakt'].update_watchlist(self, data_episode=data, update="remove")

        if full and os.path.isfile(episode_object.location):
            sickrage.app.log.info('Attempt to delete episode file %s' % episode_object.location)

            try:
                os.remove(episode_object.location)
            except OSError as e:
                sickrage.app.log.warning('Unable to delete episode file %s: %s / %s' % (episode_object.location, repr(e), str(e)))

        # delete episode from show episode cache
        sickrage.app.log.debug("Deleting %s S%02dE%02d from the shows episode cache" % (self.name, episode_object.season or 0, episode_object.episode or 0))
        try:
            del self._episodes[episode_object.episode_id]
        except KeyError:
            pass

        # delete episode from database
        sickrage.app.log.debug("Deleting %s S%02dE%02d from the DB" % (self.name, episode_object.season or 0, episode_object.episode or 0))
        episode_object.delete()

        raise EpisodeDeletedException()

    def write_show_nfo(self, force=False):
        result = False

        if not os.path.isdir(self.location):
            sickrage.app.log.info(str(self.series_id) + ": Show dir doesn't exist, skipping NFO generation")
            return False

        sickrage.app.log.debug(str(self.series_id) + ": Writing NFOs for show")
        for cur_provider in sickrage.app.metadata_providers.values():
            result = cur_provider.create_show_metadata(self, force) or result

        return result

    def write_metadata(self, show_only=False, force=False):
        if not os.path.isdir(self.location):
            sickrage.app.log.info(str(self.series_id) + ": Show dir doesn't exist, skipping NFO generation")
            return

        self.get_images()

        self.write_show_nfo(force)

        if not show_only:
            self.write_episode_nfos(force)
            self.update_episode_video_metadata()

    def write_episode_nfos(self, force=False):
        if not os.path.isdir(self.location):
            sickrage.app.log.info(str(self.series_id) + ": Show dir doesn't exist, skipping NFO generation")
            return

        sickrage.app.log.debug(str(self.series_id) + ": Writing NFOs for all episodes")

        for episode_obj in self.episodes:
            if episode_obj.location == '':
                continue

            sickrage.app.log.debug(str(self.series_id) + ": Retrieving/creating episode S%02dE%02d" % (episode_obj.season or 0, episode_obj.episode or 0))

            episode_obj.create_meta_files(force)

    def update_episode_video_metadata(self):
        if not os.path.isdir(self.location):
            sickrage.app.log.info(str(self.series_id) + ": Show dir doesn't exist, skipping video metadata updating")