logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

vvvvid.py (10826B)

    

  1. # coding: utf-8
  2. from __future__ import unicode_literals
  4. import re
  6. from .common import InfoExtractor
  7. from .youtube import YoutubeIE
  8. from ..utils import (
  9.     ExtractorError,
  10.     int_or_none,
  11.     str_or_none,
  12. )
  15. class VVVVIDIE(InfoExtractor):
  16.     _VALID_URL_BASE = r'https?://(?:www\.)?vvvvid\.it/(?:#!)?(?:show|anime|film|series)/'
  17.     _VALID_URL = r'%s(?P<show_id>\d+)/[^/]+/(?P<season_id>\d+)/(?P<id>[0-9]+)' % _VALID_URL_BASE
  18.     _TESTS = [{
  19.         # video_type == 'video/vvvvid'
  20.         'url': 'https://www.vvvvid.it/#!show/434/perche-dovrei-guardarlo-di-dario-moccia/437/489048/ping-pong',
  21.         'md5': 'b8d3cecc2e981adc3835adf07f6df91b',
  22.         'info_dict': {
  23.             'id': '489048',
  24.             'ext': 'mp4',
  25.             'title': 'Ping Pong',
  26.             'duration': 239,
  27.             'series': '"Perché dovrei guardarlo?" di Dario Moccia',
  28.             'season_id': '437',
  29.             'episode': 'Ping Pong',
  30.             'episode_number': 1,
  31.             'episode_id': '3334',
  32.             'view_count': int,
  33.             'like_count': int,
  34.             'repost_count': int,
  35.         },
  36.         'params': {
  37.             'skip_download': True,
  38.         },
  39.     }, {
  40.         # video_type == 'video/rcs'
  41.         'url': 'https://www.vvvvid.it/#!show/376/death-note-live-action/377/482493/episodio-01',
  42.         'md5': '33e0edfba720ad73a8782157fdebc648',
  43.         'info_dict': {
  44.             'id': '482493',
  45.             'ext': 'mp4',
  46.             'title': 'Episodio 01',
  47.         },
  48.         'params': {
  49.             'skip_download': True,
  50.         },
  51.     }, {
  52.         # video_type == 'video/youtube'
  53.         'url': 'https://www.vvvvid.it/show/404/one-punch-man/406/486683/trailer',
  54.         'md5': '33e0edfba720ad73a8782157fdebc648',
  55.         'info_dict': {
  56.             'id': 'RzmFKUDOUgw',
  57.             'ext': 'mp4',
  58.             'title': 'Trailer',
  59.             'upload_date': '20150906',
  60.             'description': 'md5:a5e802558d35247fee285875328c0b80',
  61.             'uploader_id': 'BandaiVisual',
  62.             'uploader': 'BANDAI NAMCO Arts Channel',
  63.         },
  64.         'params': {
  65.             'skip_download': True,
  66.         },
  67.     }, {
  68.         # video_type == 'video/dash'
  69.         'url': 'https://www.vvvvid.it/show/683/made-in-abyss/1542/693786/nanachi',
  70.         'info_dict': {
  71.             'id': '693786',
  72.             'ext': 'mp4',
  73.             'title': 'Nanachi',
  74.         },
  75.         'params': {
  76.             'skip_download': True,
  77.             'format': 'mp4',
  78.         },
  79.     }, {
  80.         'url': 'https://www.vvvvid.it/show/434/perche-dovrei-guardarlo-di-dario-moccia/437/489048',
  81.         'only_matching': True
  82.     }]
  83.     _conn_id = None
  85.     def _real_initialize(self):
  86.         self._conn_id = self._download_json(
  87.             'https://www.vvvvid.it/user/login',
  88.             None, headers=self.geo_verification_headers())['data']['conn_id']
  90.     def _download_info(self, show_id, path, video_id, fatal=True, query=None):
  91.         q = {
  92.             'conn_id': self._conn_id,
  93.         }
  94.         if query:
  95.             q.update(query)
  96.         response = self._download_json(
  97.             'https://www.vvvvid.it/vvvvid/ondemand/%s/%s' % (show_id, path),
  98.             video_id, headers=self.geo_verification_headers(), query=q, fatal=fatal)
  99.         if not (response or fatal):
  100.             return
  101.         if response.get('result') == 'error':
  102.             raise ExtractorError('%s said: %s' % (
  103.                 self.IE_NAME, response['message']), expected=True)
  104.         return response['data']
  106.     def _extract_common_video_info(self, video_data):
  107.         return {
  108.             'thumbnail': video_data.get('thumbnail'),
  109.             'episode_id': str_or_none(video_data.get('id')),
  110.         }
  112.     def _real_extract(self, url):
  113.         show_id, season_id, video_id = re.match(self._VALID_URL, url).groups()
  115.         response = self._download_info(
  116.             show_id, 'season/%s' % season_id,
  117.             video_id, query={'video_id': video_id})
  119.         vid = int(video_id)
  120.         video_data = list(filter(
  121.             lambda episode: episode.get('video_id') == vid, response))[0]
  122.         title = video_data['title']
  123.         formats = []
  125.         # vvvvid embed_info decryption algorithm is reverse engineered from function $ds(h) at vvvvid.js
  126.         def ds(h):
  127.             g = "MNOPIJKL89+/4567UVWXQRSTEFGHABCDcdefYZabstuvopqr0123wxyzklmnghij"
  129.             def f(m):
  130.                 l = []
  131.                 o = 0
  132.                 b = False
  133.                 m_len = len(m)
  134.                 while ((not b) and o < m_len):
  135.                     n = m[o] << 2
  136.                     o += 1
  137.                     k = -1
  138.                     j = -1
  139.                     if o < m_len:
  140.                         n += m[o] >> 4
  141.                         o += 1
  142.                         if o < m_len:
  143.                             k = (m[o - 1] << 4) & 255
  144.                             k += m[o] >> 2
  145.                             o += 1
  146.                             if o < m_len:
  147.                                 j = (m[o - 1] << 6) & 255
  148.                                 j += m[o]
  149.                                 o += 1
  150.                             else:
  151.                                 b = True
  152.                         else:
  153.                             b = True
  154.                     else:
  155.                         b = True
  156.                     l.append(n)
  157.                     if k != -1:
  158.                         l.append(k)
  159.                     if j != -1:
  160.                         l.append(j)
  161.                 return l
  163.             c = []
  164.             for e in h:
  165.                 c.append(g.index(e))
  167.             c_len = len(c)
  168.             for e in range(c_len * 2 - 1, -1, -1):
  169.                 a = c[e % c_len] ^ c[(e + 1) % c_len]
  170.                 c[e % c_len] = a
  172.             c = f(c)
  173.             d = ''
  174.             for e in c:
  175.                 d += chr(e)
  177.             return d
  179.         info = {}
  181.         def metadata_from_url(r_url):
  182.             if not info and r_url:
  183.                 mobj = re.search(r'_(?:S(\d+))?Ep(\d+)', r_url)
  184.                 if mobj:
  185.                     info['episode_number'] = int(mobj.group(2))
  186.                     season_number = mobj.group(1)
  187.                     if season_number:
  188.                         info['season_number'] = int(season_number)
  190.         video_type = video_data.get('video_type')
  191.         is_youtube = False
  192.         for quality in ('', '_sd'):
  193.             embed_code = video_data.get('embed_info' + quality)
  194.             if not embed_code:
  195.                 continue
  196.             embed_code = ds(embed_code)
  197.             if video_type == 'video/kenc':
  198.                 embed_code = re.sub(r'https?(://[^/]+)/z/', r'https\1/i/', embed_code).replace('/manifest.f4m', '/master.m3u8')
  199.                 kenc = self._download_json(
  200.                     'https://www.vvvvid.it/kenc', video_id, query={
  201.                         'action': 'kt',
  202.                         'conn_id': self._conn_id,
  203.                         'url': embed_code,
  204.                     }, fatal=False) or {}
  205.                 kenc_message = kenc.get('message')
  206.                 if kenc_message:
  207.                     embed_code += '?' + ds(kenc_message)
  208.                 formats.extend(self._extract_m3u8_formats(
  209.                     embed_code, video_id, 'mp4', m3u8_id='hls', fatal=False))
  210.             elif video_type == 'video/rcs':
  211.                 formats.extend(self._extract_akamai_formats(embed_code, video_id))
  212.             elif video_type == 'video/youtube':
  213.                 info.update({
  214.                     '_type': 'url_transparent',
  215.                     'ie_key': YoutubeIE.ie_key(),
  216.                     'url': embed_code,
  217.                 })
  218.                 is_youtube = True
  219.                 break
  220.             elif video_type == 'video/dash':
  221.                 formats.extend(self._extract_m3u8_formats(
  222.                     embed_code, video_id, 'mp4', m3u8_id='hls', fatal=False))
  223.             else:
  224.                 formats.extend(self._extract_wowza_formats(
  225.                     'http://sb.top-ix.org/videomg/_definst_/mp4:%s/playlist.m3u8' % embed_code, video_id))
  226.             metadata_from_url(embed_code)
  228.         if not is_youtube:
  229.             self._sort_formats(formats)
  230.             info['formats'] = formats
  232.         metadata_from_url(video_data.get('thumbnail'))
  233.         info.update(self._extract_common_video_info(video_data))
  234.         info.update({
  235.             'id': video_id,
  236.             'title': title,
  237.             'duration': int_or_none(video_data.get('length')),
  238.             'series': video_data.get('show_title'),
  239.             'season_id': season_id,
  240.             'episode': title,
  241.             'view_count': int_or_none(video_data.get('views')),
  242.             'like_count': int_or_none(video_data.get('video_likes')),
  243.             'repost_count': int_or_none(video_data.get('video_shares')),
  244.         })
  245.         return info
  248. class VVVVIDShowIE(VVVVIDIE):
  249.     _VALID_URL = r'(?P<base_url>%s(?P<id>\d+)(?:/(?P<show_title>[^/?&#]+))?)/?(?:[?#&]|$)' % VVVVIDIE._VALID_URL_BASE
  250.     _TESTS = [{
  251.         'url': 'https://www.vvvvid.it/show/156/psyco-pass',
  252.         'info_dict': {
  253.             'id': '156',
  254.             'title': 'Psycho-Pass',
  255.             'description': 'md5:94d572c0bd85894b193b8aebc9a3a806',
  256.         },
  257.         'playlist_count': 46,
  258.     }, {
  259.         'url': 'https://www.vvvvid.it/show/156',
  260.         'only_matching': True,
  261.     }]
  263.     def _real_extract(self, url):
  264.         base_url, show_id, show_title = re.match(self._VALID_URL, url).groups()
  266.         seasons = self._download_info(
  267.             show_id, 'seasons/', show_title)
  269.         show_info = self._download_info(
  270.             show_id, 'info/', show_title, fatal=False)
  272.         if not show_title:
  273.             base_url += "/title"
  275.         entries = []
  276.         for season in (seasons or []):
  277.             episodes = season.get('episodes') or []
  278.             playlist_title = season.get('name') or show_info.get('title')
  279.             for episode in episodes:
  280.                 if episode.get('playable') is False:
  281.                     continue
  282.                 season_id = str_or_none(episode.get('season_id'))
  283.                 video_id = str_or_none(episode.get('video_id'))
  284.                 if not (season_id and video_id):
  285.                     continue
  286.                 info = self._extract_common_video_info(episode)
  287.                 info.update({
  288.                     '_type': 'url_transparent',
  289.                     'ie_key': VVVVIDIE.ie_key(),
  290.                     'url': '/'.join([base_url, season_id, video_id]),
  291.                     'title': episode.get('title'),
  292.                     'description': episode.get('description'),
  293.                     'season_id': season_id,
  294.                     'playlist_title': playlist_title,
  295.                 })
  296.                 entries.append(info)
  298.         return self.playlist_result(
  299.             entries, show_id, show_info.get('title'), show_info.get('description'))