prismedia/prismedia/utils.py

#!/usr/bin/python
# coding: utf-8

from configparser import RawConfigParser, NoOptionError, NoSectionError
from os.path import dirname, splitext, basename, isfile, getmtime, exists
from yapsy.PluginManager import PluginManagerSingleton
import pluginInterfaces as pi
import re
import unidecode
import logging
import datetime

logger = logging.getLogger("Prismedia")

VALID_PRIVACY_STATUSES = ("public", "private", "unlisted")
VALID_CATEGORIES = (
    "music", "films", "vehicles",
    "sports", "travels", "gaming", "people",
    "comedy", "entertainment", "news",
    "how to", "education", "activism", "science & technology",
    "science", "technology", "animals"
)
VALID_LANGUAGES = ("arabic", "english", "french",
                   "german", "hindi", "italian",
                   "japanese", "korean", "mandarin",
                   "portuguese", "punjabi", "russian", "spanish")
VALID_PROGRESS = ("percentage", "bigfile", "accurate")


def helperFunctionalities(options):
    pluginManager = PluginManagerSingleton.get()

    optionName = "--heartbeat"
    if options.get(optionName):
        for plugin in pluginManager.getPluginsOfCategory(pi.PluginTypes.PLATFORM):
            plugin.plugin_object.heartbeat()
        return False
    else:
        options.pop(optionName)

    return True


def get_exception_string(e):
    if hasattr(e, "message"):
        return str(e.message)
    else:
        return str(e)


def validateVideo(path):
    supported_types = ["video/mp4"]
    detected_type = magic.from_file(path, mime=True)
    if detected_type not in supported_types:
        print("File", path, "detected type is `" + detected_type + "` which is not one of", supported_types)

        force_file = ["y", "yes"]
        is_forcing = input("Are you sure you selected the correct file? (y/N)")
        if is_forcing.lower() not in force_file:
            return False

    return path


def validateCategory(category):
    if category.lower() in VALID_CATEGORIES:
        return True
    else:
        return False


def validatePrivacy(privacy):
    if privacy.lower() in VALID_PRIVACY_STATUSES:
        return True
    else:
        return False


# TODO: remove me?
# def validatePlatform(platform):
#     for plfrm in platform.split(','):
#         if plfrm.lower().replace(" ", "") not in VALID_PLATFORM:
#             return False
#
#     return True


def validateLanguage(language):
    if language.lower() in VALID_LANGUAGES:
        return True
    else:
        return False


def validateDate(date):
    return datetime.datetime.strptime(date, "%Y-%m-%dT%H:%M:%S")


def validatePublishDate(publishDate):
    # Check date format and if date is future
    try:
        now = datetime.datetime.now()
        publishAt = validateDate(publishDate)
        if now >= publishAt:
            return False
    except ValueError:
        return False
    return True


def validateOriginalDate(originalDate):
    # Check date format and if date is past
    try:
        now = datetime.datetime.now()
        originalDate = validateDate(originalDate)
        if now <= originalDate:
            return False
    except ValueError:
        return False
    return True


def validateThumbnail(thumbnail):
    supported_types = ['image/jpg', 'image/jpeg']
    if exists(thumbnail) and \
            magic.from_file(thumbnail, mime=True) in supported_types:
        return thumbnail
    else:
        return False


def validateLogLevel(loglevel):
    numeric_level = getattr(logging, loglevel, None)
    if not isinstance(numeric_level, int):
        return False
    return True


def validateProgress(progress):
    for prgs in progress.split(','):
        if prgs.lower().replace(" ", "") not in VALID_PROGRESS:
            return False

    return True


def ask_overwrite(question):
    while True:
        reply = str(input(question + ' (Yes/[No]): ') or "No").lower().strip()
        if reply[:1] == 'y':
            return True
        if reply[:1] == 'n':
            return False


def remove_empty_kwargs(**kwargs):
    good_kwargs = {}
    if kwargs is not None:
        for key, value in kwargs.items():
            if value:
                good_kwargs[key] = value
    return good_kwargs


def searchOriginalDate(options):
    fileModificationDate = str(getmtime(options.get('--file'))).split('.')
    return datetime.datetime.fromtimestamp(int(fileModificationDate[0])).isoformat()


# # return the nfo as a RawConfigParser object
# def loadNFO(filename):
#     try:
#         logger.info("Loading " + filename + " as NFO")
#         nfo = RawConfigParser()
#         nfo.read(filename, encoding='utf-8')
#         return nfo
#     except Exception as e:
#         logger.critical("Problem loading NFO file " + filename + ": " + str(e))
#         exit(1)
#     return False
#
#
# def parseNFO(options):
#     video_directory = dirname(options.get('--file'))
#     directory_name = basename(video_directory)
#     nfo_txt = False
#     nfo_directory = False
#     nfo_videoname = False
#     nfo_file = False
#     nfo_cli = False
#
#     if isfile(video_directory + "/" + "nfo.txt"):
#         nfo_txt = loadNFO(video_directory + "/" + "nfo.txt")
#     elif isfile(video_directory + "/" + "NFO.txt"):
#         nfo_txt = loadNFO(video_directory + "/" + "NFO.txt")
#
#     if isfile(video_directory + "/" + directory_name + ".txt"):
#         nfo_directory = loadNFO(video_directory + "/" + directory_name + ".txt")
#
#     if options.get('--name'):
#         if isfile(video_directory + "/" + options.get('--name')):
#             nfo_videoname = loadNFO(video_directory + "/" + options.get('--name') + ".txt")
#
#     video_file = splitext(basename(options.get('--file')))[0]
#     if isfile(video_directory + "/" + video_file + ".txt"):
#         nfo_file = loadNFO(video_directory + "/" + video_file + ".txt")
#
#     if options.get('--nfo'):
#         if isfile(options.get('--nfo')):
#             nfo_cli = loadNFO(options.get('--nfo'))
#         else:
#             logger.critical("Given NFO file does not exist, please check your path.")
#             exit(1)
#
#     # If there is no NFO and strict option is enabled, then stop there
#     if options.get('--withNFO'):
#         if not isinstance(nfo_cli, RawConfigParser) and \
#                 not isinstance(nfo_file, RawConfigParser) and \
#                 not isinstance(nfo_videoname, RawConfigParser) and \
#                 not isinstance(nfo_directory, RawConfigParser) and \
#                 not isinstance(nfo_txt, RawConfigParser):
#             logger.critical("You have required the strict presence of NFO but none is found, please use a NFO.")
#             exit(1)
#
#     # We need to load NFO in this exact order to keep the priorities
#     # options in cli > nfo_cli > nfo_file > nfo_videoname > nfo_directory > nfo_txt
#     for nfo in [nfo_cli, nfo_file, nfo_videoname, nfo_directory, nfo_txt]:
#         if nfo:
#             # We need to check all options and replace it with the nfo value if not defined (None or False)
#             for key, value in options.items():
#                 key = key.replace("--", "")
#                 try:
#                     # get string options
#                     if value is None and nfo.get('video', key):
#                         options['--' + key] = nfo.get('video', key)
#                     # get boolean options
#                     elif value is False and nfo.getboolean('video', key):
#                         options['--' + key] = nfo.getboolean('video', key)
#                 except NoOptionError:
#                     continue
#                 except NoSectionError:
#                     logger.critical(nfo + " misses section [video], please check syntax of your NFO.")
#                     exit(1)
#     return options


def cleanString(toclean):
    toclean = unidecode.unidecode(toclean)
    cleaned = re.sub('[^A-Za-z0-9]+', '', toclean)

    return cleaned


def getOption(options, optionName, defaultValue=None):
    value = options.get(optionName)
    options.pop(optionName)

    if value is None:
        return defaultValue
    return value