sharky555
/
SM-AU-TV
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
9 Commity
1 Gałąź
96 KiB
 
Drzewo: 9a049cc12e
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '9a049cc12e'
${ noResults }
SM-AU-TV/jps2sm/validation.py

224 wiersze
9.2 KiB
Czysty Wina Historia 

  1. # Standard library packages

  2. import logging

  3. import re

  4. 

  5. from jps2sm.myloginsession import jpopsuki

  6. from jps2sm.constants import Categories, VideoOptions

  7. from jps2sm.utils import GetArgs

  8. 

  9. # Third-party packages

  10. from bs4 import BeautifulSoup

  11. import torrent_parser as tp

  12. 

  13. logger = logging.getLogger('main.' + __name__)

  14. 

  15. 

  16. def decide_music_performance(artists, multiplefiles, duration):

  17.     """

  18.     Return if upload should be a Music Performance or not

  19.     A music performance is a cut from a Music TV show and is 25 mins or less long and therefore also not a TV Show artist

  20. 

  21.     We assume we are being called if Cat = TV Music

  22. 

  23.     :return:  str: 'Music Performance' or 'TV Music'

  24.     """

  25.     if multiplefiles is True or duration > 1500000:  # 1 500 000 ms = 25 mins

  26.         return 'TV Music'

  27.     else:  # Single file that is < 25 mins, decide if Music Performance

  28.         if len(artists) > 1:  # Multiple artists

  29.             logger.debug('Upload is a Music Performance as it has derived multiple artists and is 25 mins or less')

  30.             return 'Music Performance'  # JPS TV Show artists never have multiple artists

  31.         JPSartistpage = jpopsuki(f"https://jpopsuki.eu/artist.php?name={artists[0]}")

  32.         soup = BeautifulSoup(JPSartistpage.text, 'html5lib')

  33.         categoriesbox = str(soup.select('#content .thin .main_column .box.center'))

  34.         categories = re.findall(r'\[(.+)\]', categoriesbox)

  35.         if any({*Categories.NonTVCategories} & {*categories}):  # Exclude any TV Shows for being mislabeled as Music Performance

  36.             logger.debug('Upload is a Music Performance as it is 25 mins or less and not a TV Show')

  37.             return 'Music Performance'

  38.         else:

  39.             logger.debug('Upload is not a Music Performance')

  40.             return 'TV Music'

  41. 

  42. 

  43. def get_alternate_fansub_category_id(artist, group_name):

  44.     """

  45.     Attempts to detect the actual category for JPS Fansubs category torrents and if not ask the user to select an alternate category.

  46.     If it is a TV show, this TV show category type is detected and returned, else query the user from a list of potential categories.

  47. 

  48.     :param artist: str artist name

  49.     :return: int alternative category ID based on Categories.SM()

  50.     """

  51.     JPSartistpage = jpopsuki(f"https://jpopsuki.eu/artist.php?name={artist}")

  52.     soup = BeautifulSoup(JPSartistpage.text, 'html5lib')

  53.     categoriesbox = str(soup.select('#content .thin .main_column .box.center'))

  54.     categories = re.findall(r'\[(.+)\]', categoriesbox)

  55. 

  56.     if not any({*Categories.NonTVCategories} & {*categories}) and " ".join(categories).count('TV-') == 1:

  57.         # Artist has no music and only 1 TV Category, artist is a TV show and we can auto detect the category for FanSub releases

  58.         autodetectcategory = re.findall(r'(TV-(?:[^ ]+))', " ".join(categories))[0]

  59.         logger.debug(f'Autodetected SM category {autodetectcategory} for JPS Fansubs torrent')

  60.         return autodetectcategory

  61.     else:  # Cannot autodetect

  62.         AlternateFanSubCategoriesIDs = (5, 6, 7, 8, 9, 11)  # Matches indices in Categories()

  63.         logger.warning(f'Cannot auto-detect correct category for torrent group {group_name}.')

  64.         print('Select Category:')

  65.         option = 1

  66.         optionlookup = {}

  67.         for alternativefansubcategoryid in AlternateFanSubCategoriesIDs:

  68.             for cat, catid in Categories.SM.items():

  69.                 if alternativefansubcategoryid == catid:

  70.                     print(f'({option}) {cat}')

  71.                     optionlookup[option] = alternativefansubcategoryid

  72.                     option += 1

  73.         alternatecategoryoption = input('Choose alternate category or press ENTER to skip: ')

  74.         if alternatecategoryoption == "":

  75.             logger.error('No alternate Fansubs category chosen.')

  76.             return "Fansubs"  # Allow upload to fail

  77.         else:

  78.             category = optionlookup[int(alternatecategoryoption)]

  79.             logger.info(f'Alternate Fansubs category {category} chosen')

  80.             return category

  81. 

  82. 

  83. def validate_jps_video_data(releasedata, categorystatus):

  84.     """

  85.     Validate and process dict supplied by getreleasedata() via collate() to extract all available data

  86.     from JPS for video torrents, whilst handling weird cases where VideoTorrent is uploaded as a Music category

  87. 

  88.     :param releasedata:

  89.     :param categorystatus: str: good or bad. good for correct category assigned and bad if this is a Music Torrent

  90.     mistakenly uploaded as a non-VC category!

  91.     :return: releasedataout{} validated container, codec, media, audioformat

  92.     """

  93.     releasedataout = {}

  94.     # JPS uses the audioformat field (represented as releasedata[0] here) for containers and codecs in video torrents

  95. 

  96.     # If a known container is used as audioformat set it as the container on SM

  97.     if releasedata[0] in VideoOptions.badcontainers:

  98.         releasedataout['container'] = releasedata[0]

  99.     else:

  100.         releasedataout['container'] = 'CHANGEME'

  101.     # If a known codec is used as audioformat set it as the codec on SM

  102.     if releasedata[0] in VideoOptions.badcodecs:

  103.         if releasedata[0] == "MPEG2":  # JPS uses 'MPEG2' for codec instead of the correct 'MPEG-2'

  104.             releasedataout['codec'] = "MPEG-2"

  105.         else:

  106.             releasedataout['codec'] = releasedata[0]

  107.     else:

  108.         releasedataout['codec'] = 'CHANGEME'  # assume default

  109. 

  110.     if categorystatus == "good":

  111.         releasedataout['media'] = releasedata[1]

  112.     else:

  113.         releasedataout['media'] = releasedata[2]

  114. 

  115.     if releasedata[0] == 'AAC':  # For video torrents, the only correct audioformat in JPS is AAC

  116.         releasedataout['audioformat'] = "AAC"

  117.     else:

  118.         releasedataout['audioformat'] = "CHANGEME"

  119. 

  120.     return releasedataout

  121. 

  122. 

  123. def validate_jps_bitrate(jps_bitrate):

  124.     """

  125.     Validate JPS bad bitrates to sensible bitrates ready for upload to SM

  126. 

  127.     :param jps_bitrate:

  128.     :return: sm_bitrate

  129.     """

  130. 

  131.     bitrates = {

  132.         "Hi-Res 96/24": "24bit Lossless 96kHz",

  133.         "24bit/48kHz": "24bit Lossless 48kHz",

  134.         "Hi-Res": "24bit Lossless",

  135.         "Hi-Res 48/24": "24bit Lossless 48kHz",

  136.         "24bit/96kHz": "24bit Lossless 96kHz",

  137.         "24bit/48Khz": "24bit Lossless 48kHz",

  138.         "24bit/96Khz": "24bit Lossless 96kHz",

  139.         "24bit/48khz": "24bit Lossless 48kHz",

  140.         "Hi-Res Lossless": "24bit Lossless",

  141.         "160": "Other",

  142.         "Variable": "Other",

  143.         "320 (VBR)": "Other",

  144.         "Scans": "",

  145.         "Booklet": "",

  146.         "1080p": "",

  147.         "720p": "",

  148.         "256 (VBR)": "APS (VBR)",

  149.         "155": "Other"

  150.     }

  151. 

  152.     sm_bitrate = jps_bitrate  # Default is to leave bitrate alone if not mentioned here, such as bitrates that are OK on both JPS and SM

  153.     for old, new in bitrates.items():

  154.         if jps_bitrate == old:

  155.             sm_bitrate = new

  156. 

  157.     return sm_bitrate

  158. 

  159. 

  160. def decide_exc_filter(audioformat, media, releasedata):

  161.     """

  162.     Implement audioformat and media exclusion filters

  163.     :return: boolean: True or False

  164.     """

  165.     args = GetArgs()

  166. 

  167.     if audioformat == args.parsed.excaudioformat:

  168.         logger.info(f'Excluding {releasedata} as exclude audioformat {args.parsed.excaudioformat} is set')

  169.         return True

  170.     elif media == args.parsed.excmedia:

  171.         logger.info(f'Excluding {releasedata} as exclude media {args.parsed.excmedia} is set')

  172.         return True

  173. 

  174.     return False

  175. 

  176. 

  177. def decide_ep(torrentfilename, uploaddata):

  178.     """

  179.     Return if Album upload should be an EP or not.

  180.     EPs are considered to have < 7 tracks, excluding off-vocals and uploaded to JPS as an Album

  181. 

  182.     We assume we are being called only if Cat = Album

  183. 

  184.     :param torrentfilename:

  185.     :param uploaddata:

  186.     :return: str: 'EP' or 'Album'

  187.     """

  188. 

  189.     if uploaddata['media'].lower() == 'bluray' or uploaddata['media'].lower() == 'dvd':

  190.         return 'Album'

  191. 

  192.     torrent_metadata = tp.parse_torrent_file(torrentfilename)

  193.     music_extensions = ['.flac', '.mp3', '.ogg', '.alac', '.m4a', '.wav', '.wma', '.ra']

  194.     off_vocal_phrases = ['off-vocal', 'offvocal', 'off vocal', 'inst.', 'instrumental', 'english ver', 'japanese ver', 'korean ver']

  195.     track_count = 0

  196.     has_cue = False

  197.     track_extensions = set()

  198.     for file in torrent_metadata['info']['files']:

  199.         file_path = file['path'][-1].lower()

  200. 

  201.         if file_path.endswith('.iso'):

  202.             return 'Album'

  203. 

  204.         if file_path.endswith('.cue'):

  205.             has_cue = True

  206. 

  207.         if list(filter(file_path.endswith, music_extensions)) and \

  208.                 not any(substring in file_path for substring in off_vocal_phrases):

  209.             #  Count music files which are not an off-vocal or instrumental

  210.             logger.debug(f"Deciding if EP with torrent with these tracks: {file['path'][-1]}")

  211.             track_count += 1

  212.             track_extensions.add(file_path.split('.')[-1])

  213. 

  214.     if has_cue and track_extensions == {'flac'}:

  215.         logger.debug(f'Upload is not an EP as it has a .cue file and only .flac files')

  216.         return 'Album'

  217. 

  218.     if track_count < 7:

  219.         logger.debug(f'Upload is an EP as it has {track_count} standard tracks')

  220.         return 'EP'

  221.     else:

  222.         logger.debug(f'Upload is not an EP as it has {track_count} tracks')

  223.         return 'Album'