[yt-dlp.git] / youtube_dlc / extractor / viki.py

# coding: utf-8
from __future__ import unicode_literals

import base64
import hashlib
import hmac
import itertools
import json
import re
import time

from .common import InfoExtractor
from ..compat import (
    compat_parse_qs,
    compat_urllib_parse_urlparse,
)
from ..utils import (
    ExtractorError,
    int_or_none,
    HEADRequest,
    parse_age_limit,
    parse_iso8601,
    sanitized_Request,
    std_headers,
)


class VikiBaseIE(InfoExtractor):
    _VALID_URL_BASE = r'https?://(?:www\.)?viki\.(?:com|net|mx|jp|fr)/'
    _API_QUERY_TEMPLATE = '/v4/%sapp=%s&t=%s&site=www.viki.com'
    _API_URL_TEMPLATE = 'https://api.viki.io%s&sig=%s'

    _APP = '100005a'
    _APP_VERSION = '2.2.5.1428709186'
    _APP_SECRET = 'MM_d*yP@`&1@]@!AVrXf_o-HVEnoTnm$O-ti4[G~$JDI/Dc-&piU&z&5.;:}95=Iad'

    _GEO_BYPASS = False
    _NETRC_MACHINE = 'viki'

    _token = None

    _ERRORS = {
        'geo': 'Sorry, this content is not available in your region.',
        'upcoming': 'Sorry, this content is not yet available.',
        # 'paywall': 'paywall',
    }

    def _prepare_call(self, path, timestamp=None, post_data=None):
        path += '?' if '?' not in path else '&'
        if not timestamp:
            timestamp = int(time.time())
        query = self._API_QUERY_TEMPLATE % (path, self._APP, timestamp)
        if self._token:
            query += '&token=%s' % self._token
        sig = hmac.new(
            self._APP_SECRET.encode('ascii'),
            query.encode('ascii'),
            hashlib.sha1
        ).hexdigest()
        url = self._API_URL_TEMPLATE % (query, sig)
        return sanitized_Request(
            url, json.dumps(post_data).encode('utf-8')) if post_data else url

    def _call_api(self, path, video_id, note, timestamp=None, post_data=None):
        resp = self._download_json(
            self._prepare_call(path, timestamp, post_data), video_id, note)

        error = resp.get('error')
        if error:
            if error == 'invalid timestamp':
                resp = self._download_json(
                    self._prepare_call(path, int(resp['current_timestamp']), post_data),
                    video_id, '%s (retry)' % note)
                error = resp.get('error')
            if error:
                self._raise_error(resp['error'])

        return resp

    def _raise_error(self, error):
        raise ExtractorError(
            '%s returned error: %s' % (self.IE_NAME, error),
            expected=True)

    def _check_errors(self, data):
        for reason, status in data.get('blocking', {}).items():
            if status and reason in self._ERRORS:
                message = self._ERRORS[reason]
                if reason == 'geo':
                    self.raise_geo_restricted(msg=message)
                raise ExtractorError('%s said: %s' % (
                    self.IE_NAME, message), expected=True)

    def _real_initialize(self):
        self._login()

    def _login(self):
        username, password = self._get_login_info()
        if username is None:
            return

        login_form = {
            'login_id': username,
            'password': password,
        }

        login = self._call_api(
            'sessions.json', None,
            'Logging in', post_data=login_form)

        self._token = login.get('token')
        if not self._token:
            self.report_warning('Unable to get session token, login has probably failed')

    @staticmethod
    def dict_selection(dict_obj, preferred_key, allow_fallback=True):
        if preferred_key in dict_obj:
            return dict_obj.get(preferred_key)

        if not allow_fallback:
            return

        filtered_dict = list(filter(None, [dict_obj.get(k) for k in dict_obj.keys()]))
        return filtered_dict[0] if filtered_dict else None


class VikiIE(VikiBaseIE):
    IE_NAME = 'viki'
    _VALID_URL = r'%s(?:videos|player)/(?P<id>[0-9]+v)' % VikiBaseIE._VALID_URL_BASE
    _TESTS = [{
        'url': 'http://www.viki.com/videos/1023585v-heirs-episode-14',
        'info_dict': {
            'id': '1023585v',
            'ext': 'mp4',
            'title': 'Heirs Episode 14',
            'uploader': 'SBS',
            'description': 'md5:c4b17b9626dd4b143dcc4d855ba3474e',
            'upload_date': '20131121',
            'age_limit': 13,
        },
        'skip': 'Blocked in the US',
    }, {
        # clip
        'url': 'http://www.viki.com/videos/1067139v-the-avengers-age-of-ultron-press-conference',
        'md5': '86c0b5dbd4d83a6611a79987cc7a1989',
        'info_dict': {
            'id': '1067139v',
            'ext': 'mp4',
            'title': "'The Avengers: Age of Ultron' Press Conference",
            'description': 'md5:d70b2f9428f5488321bfe1db10d612ea',
            'duration': 352,
            'timestamp': 1430380829,
            'upload_date': '20150430',
            'uploader': 'Arirang TV',
            'like_count': int,
            'age_limit': 0,
        }
    }, {
        'url': 'http://www.viki.com/videos/1048879v-ankhon-dekhi',
        'info_dict': {
            'id': '1048879v',
            'ext': 'mp4',
            'title': 'Ankhon Dekhi',
            'duration': 6512,
            'timestamp': 1408532356,
            'upload_date': '20140820',
            'uploader': 'Spuul',
            'like_count': int,
            'age_limit': 13,
        },
        'skip': 'Blocked in the US',
    }, {
        # episode
        'url': 'http://www.viki.com/videos/44699v-boys-over-flowers-episode-1',
        'md5': '94e0e34fd58f169f40c184f232356cfe',
        'info_dict': {
            'id': '44699v',
            'ext': 'mp4',
            'title': 'Boys Over Flowers - Episode 1',
            'description': 'md5:b89cf50038b480b88b5b3c93589a9076',
            'duration': 4172,
            'timestamp': 1270496524,
            'upload_date': '20100405',
            'uploader': 'group8',
            'like_count': int,
            'age_limit': 13,
        },
        'expected_warnings': ['Unknown MIME type image/jpeg in DASH manifest'],
    }, {
        # youtube external
        'url': 'http://www.viki.com/videos/50562v-poor-nastya-complete-episode-1',
        'md5': '63f8600c1da6f01b7640eee7eca4f1da',
        'info_dict': {
            'id': '50562v',
            'ext': 'webm',
            'title': 'Poor Nastya [COMPLETE] - Episode 1',
            'description': '',
            'duration': 606,
            'timestamp': 1274949505,
            'upload_date': '20101213',
            'uploader': 'ad14065n',
            'uploader_id': 'ad14065n',
            'like_count': int,
            'age_limit': 13,
        },
        'skip': 'Page not found!',
    }, {
        'url': 'http://www.viki.com/player/44699v',
        'only_matching': True,
    }, {
        # non-English description
        'url': 'http://www.viki.com/videos/158036v-love-in-magic',
        'md5': 'adf9e321a0ae5d0aace349efaaff7691',
        'info_dict': {
            'id': '158036v',
            'ext': 'mp4',
            'uploader': 'I Planet Entertainment',
            'upload_date': '20111122',
            'timestamp': 1321985454,
            'description': 'md5:44b1e46619df3a072294645c770cef36',
            'title': 'Love In Magic',
            'age_limit': 13,
        },
    }]

    def _real_extract(self, url):
        video_id = self._match_id(url)

        resp = self._download_json(
            'https://www.viki.com/api/videos/' + video_id,
            video_id, 'Downloading video JSON', headers={
                'x-client-user-agent': std_headers['User-Agent'],
                'x-viki-app-ver': '4.0.57',
            })
        video = resp['video']

        self._check_errors(video)

        title = self.dict_selection(video.get('titles', {}), 'en', allow_fallback=False)
        if not title:
            title = 'Episode %d' % video.get('number') if video.get('type') == 'episode' else video.get('id') or video_id
            container_titles = video.get('container', {}).get('titles', {})
            container_title = self.dict_selection(container_titles, 'en')
            title = '%s - %s' % (container_title, title)

        description = self.dict_selection(video.get('descriptions', {}), 'en')

        duration = int_or_none(video.get('duration'))
        timestamp = parse_iso8601(video.get('created_at'))
        uploader = video.get('author')
        like_count = int_or_none(video.get('likes', {}).get('count'))
        age_limit = parse_age_limit(video.get('rating'))

        thumbnails = []
        for thumbnail_id, thumbnail in video.get('images', {}).items():
            thumbnails.append({
                'id': thumbnail_id,
                'url': thumbnail.get('url'),
            })

        subtitles = {}
        try:
            # New way to fetch subtitles
            new_video = self._download_json(
                'https://www.viki.com/api/videos/%s' % video_id, video_id,
                'Downloading new video JSON to get subtitles', fatal=False)
            for sub in new_video.get('streamSubtitles').get('dash'):
                subtitles[sub.get('srclang')] = [{
                    'ext': 'vtt',
                    'url': sub.get('src'),
                    'completion': sub.get('percentage'),
                }]
        except AttributeError:
            # fall-back to the old way if there isn't a streamSubtitles attribute
            for subtitle_lang, _ in video.get('subtitle_completions', {}).items():
                subtitles[subtitle_lang] = [{
                    'ext': subtitles_format,
                    'url': self._prepare_call(
                        'videos/%s/subtitles/%s.%s' % (video_id, subtitle_lang, subtitles_format)),
                } for subtitles_format in ('srt', 'vtt')]

        result = {
            'id': video_id,
            'title': title,
            'description': description,
            'duration': duration,
            'timestamp': timestamp,
            'uploader': uploader,
            'like_count': like_count,
            'age_limit': age_limit,
            'thumbnails': thumbnails,
            'subtitles': subtitles,
        }

        formats = []

        def add_format(format_id, format_dict, protocol='http'):
            # rtmps URLs does not seem to work
            if protocol == 'rtmps':
                return
            format_url = format_dict.get('url')
            if not format_url:
                return
            format_drms = format_dict.get('drms')
            format_stream_id = format_dict.get('id')
            qs = compat_parse_qs(compat_urllib_parse_urlparse(format_url).query)
            stream = qs.get('stream', [None])[0]
            if stream:
                format_url = base64.b64decode(stream).decode()
            if format_id in ('m3u8', 'hls'):
                m3u8_formats = self._extract_m3u8_formats(
                    format_url, video_id, 'mp4',
                    entry_protocol='m3u8_native',
                    m3u8_id='m3u8-%s' % protocol, fatal=False)
                # Despite CODECS metadata in m3u8 all video-only formats
                # are actually video+audio
                for f in m3u8_formats:
                    if '_drm/index_' in f['url']:
                        continue
                    if f.get('acodec') == 'none' and f.get('vcodec') != 'none':
                        f['acodec'] = None
                    formats.append(f)
            elif format_id in ('mpd', 'dash'):
                formats.extend(self._extract_mpd_formats(
                    format_url, video_id, 'mpd-%s' % protocol, fatal=False))
            elif format_url.startswith('rtmp'):
                mobj = re.search(
                    r'^(?P<url>rtmp://[^/]+/(?P<app>.+?))/(?P<playpath>mp4:.+)$',
                    format_url)
                if not mobj:
                    return
                formats.append({
                    'format_id': 'rtmp-%s' % format_id,
                    'ext': 'flv',
                    'url': mobj.group('url'),
                    'play_path': mobj.group('playpath'),
                    'app': mobj.group('app'),
                    'page_url': url,
                    'drms': format_drms,
                    'stream_id': format_stream_id,
                })
            else:
                urlh = self._request_webpage(
                    HEADRequest(format_url), video_id, 'Checking file size', fatal=False)
                formats.append({
                    'url': format_url,
                    'format_id': '%s-%s' % (format_id, protocol),
                    'height': int_or_none(self._search_regex(
                        r'^(\d+)[pP]$', format_id, 'height', default=None)),
                    'drms': format_drms,
                    'stream_id': format_stream_id,
                    'filesize': int_or_none(urlh.headers.get('Content-Length')),
                })

        for format_id, format_dict in (resp.get('streams') or {}).items():
            add_format(format_id, format_dict)
        if not formats:
            streams = self._call_api(
                'videos/%s/streams.json' % video_id, video_id,
                'Downloading video streams JSON')

            if 'external' in streams:
                result.update({
                    '_type': 'url_transparent',
                    'url': streams['external']['url'],
                })
                return result

            for format_id, stream_dict in streams.items():
                for protocol, format_dict in stream_dict.items():
                    add_format(format_id, format_dict, protocol)
        self._sort_formats(formats)

        result['formats'] = formats
        return result


class VikiChannelIE(VikiBaseIE):
    IE_NAME = 'viki:channel'
    _VALID_URL = r'%s(?:tv|news|movies|artists)/(?P<id>[0-9]+c)' % VikiBaseIE._VALID_URL_BASE
    _TESTS = [{
        'url': 'http://www.viki.com/tv/50c-boys-over-flowers',
        'info_dict': {
            'id': '50c',
            'title': 'Boys Over Flowers',
            'description': 'md5:ecd3cff47967fe193cff37c0bec52790',
        },
        'playlist_mincount': 71,
    }, {
        'url': 'http://www.viki.com/tv/1354c-poor-nastya-complete',
        'info_dict': {
            'id': '1354c',
            'title': 'Poor Nastya [COMPLETE]',
            'description': 'md5:05bf5471385aa8b21c18ad450e350525',
        },
        'playlist_count': 127,
    }, {
        'url': 'http://www.viki.com/news/24569c-showbiz-korea',
        'only_matching': True,
    }, {
        'url': 'http://www.viki.com/movies/22047c-pride-and-prejudice-2005',
        'only_matching': True,
    }, {
        'url': 'http://www.viki.com/artists/2141c-shinee',
        'only_matching': True,
    }]

    _PER_PAGE = 25

    def _real_extract(self, url):
        channel_id = self._match_id(url)

        channel = self._call_api(
            'containers/%s.json' % channel_id, channel_id,
            'Downloading channel JSON')

        self._check_errors(channel)

        title = self.dict_selection(channel['titles'], 'en')

        description = self.dict_selection(channel['descriptions'], 'en')

        entries = []
        for video_type in ('episodes', 'clips', 'movies'):
            for page_num in itertools.count(1):
                page = self._call_api(
                    'containers/%s/%s.json?per_page=%d&sort=number&direction=asc&with_paging=true&page=%d'
                    % (channel_id, video_type, self._PER_PAGE, page_num), channel_id,
                    'Downloading %s JSON page #%d' % (video_type, page_num))
                for video in page['response']:
                    video_id = video['id']
                    entries.append(self.url_result(
                        'https://www.viki.com/videos/%s' % video_id, 'Viki'))
                if not page['pagination']['next']:
                    break

        return self.playlist_result(entries, channel_id, title, description)
Commit	Line	Data
accf79b1	1	# coding: utf-8
cb9722cb PH	2	from __future__ import unicode_literals
cb9722cb PH	3
a0566bbf	4	import base64
1a83c731	5	import hashlib
9338a0ea	6	import hmac
bc56355e	7	import itertools
9338a0ea S	8	import json
	9	import re
	10	import time
382ed50e	11
5c2266df	12	from .common import InfoExtractor
a0566bbf	13	from ..compat import (
	14	compat_parse_qs,
	15	compat_urllib_parse_urlparse,
	16	)
382ed50e	17	from ..utils import (
6d88bc37	18	ExtractorError,
1a83c731	19	int_or_none,
169bd46b	20	HEADRequest,
1a83c731 S	21	parse_age_limit,
1a83c731 S	22	parse_iso8601,
5c2266df	23	sanitized_Request,
38d70284	24	std_headers,
382ed50e	25	)
382ed50e PH	26
382ed50e PH	27
1a83c731	28	class VikiBaseIE(InfoExtractor):
53de95da	29	_VALID_URL_BASE = r'https?://(?:www\.)?viki\.(?:com\|net\|mx\|jp\|fr)/'
1a83c731	30	_API_QUERY_TEMPLATE = '/v4/%sapp=%s&t=%s&site=www.viki.com'
26a87972	31	_API_URL_TEMPLATE = 'https://api.viki.io%s&sig=%s'
1a83c731	32
8251af63	33	_APP = '100005a'
1a83c731	34	_APP_VERSION = '2.2.5.1428709186'
8251af63	35	_APP_SECRET = 'MM_d*yP@`&1@]@!AVrXf_o-HVEnoTnm$O-ti4[G~$JDI/Dc-&piU&z&5.;:}95=Iad'
1a83c731	36
4248dad9	37	_GEO_BYPASS = False
accf79b1 S	38	_NETRC_MACHINE = 'viki'
accf79b1 S	39
16d6973f S	40	_token = None
16d6973f S	41
dc016bf5	42	_ERRORS = {
	43	'geo': 'Sorry, this content is not available in your region.',
	44	'upcoming': 'Sorry, this content is not yet available.',
	45	# 'paywall': 'paywall',
	46	}
	47
accf79b1	48	def _prepare_call(self, path, timestamp=None, post_data=None):
1a83c731 S	49	path += '?' if '?' not in path else '&'
	50	if not timestamp:
	51	timestamp = int(time.time())
	52	query = self._API_QUERY_TEMPLATE % (path, self._APP, timestamp)
16d6973f S	53	if self._token:
16d6973f S	54	query += '&token=%s' % self._token
1a83c731 S	55	sig = hmac.new(
	56	self._APP_SECRET.encode('ascii'),
	57	query.encode('ascii'),
	58	hashlib.sha1
	59	).hexdigest()
accf79b1	60	url = self._API_URL_TEMPLATE % (query, sig)
5c2266df	61	return sanitized_Request(
accf79b1	62	url, json.dumps(post_data).encode('utf-8')) if post_data else url
1a83c731	63
accf79b1	64	def _call_api(self, path, video_id, note, timestamp=None, post_data=None):
1a83c731	65	resp = self._download_json(
29f7c58a	66	self._prepare_call(path, timestamp, post_data), video_id, note)
1a83c731 S	67
	68	error = resp.get('error')
	69	if error:
	70	if error == 'invalid timestamp':
	71	resp = self._download_json(
accf79b1	72	self._prepare_call(path, int(resp['current_timestamp']), post_data),
29f7c58a	73	video_id, '%s (retry)' % note)
1a83c731 S	74	error = resp.get('error')
	75	if error:
	76	self._raise_error(resp['error'])
	77
	78	return resp
	79
	80	def _raise_error(self, error):
	81	raise ExtractorError(
	82	'%s returned error: %s' % (self.IE_NAME, error),
	83	expected=True)
	84
dc016bf5	85	def _check_errors(self, data):
	86	for reason, status in data.get('blocking', {}).items():
	87	if status and reason in self._ERRORS:
5d3fbf77 S	88	message = self._ERRORS[reason]
	89	if reason == 'geo':
	90	self.raise_geo_restricted(msg=message)
dc016bf5	91	raise ExtractorError('%s said: %s' % (
5d3fbf77	92	self.IE_NAME, message), expected=True)
dc016bf5	93
accf79b1 S	94	def _real_initialize(self):
	95	self._login()
	96
	97	def _login(self):
68217024	98	username, password = self._get_login_info()
accf79b1 S	99	if username is None:
	100	return
	101
	102	login_form = {
	103	'login_id': username,
	104	'password': password,
	105	}
	106
16d6973f	107	login = self._call_api(
accf79b1	108	'sessions.json', None,
e4d95865	109	'Logging in', post_data=login_form)
accf79b1	110
16d6973f S	111	self._token = login.get('token')
	112	if not self._token:
	113	self.report_warning('Unable to get session token, login has probably failed')
	114
b73b14f7	115	@staticmethod
6d28c408	116	def dict_selection(dict_obj, preferred_key, allow_fallback=True):
b73b14f7 YCH	117	if preferred_key in dict_obj:
	118	return dict_obj.get(preferred_key)
	119
6d28c408 YCH	120	if not allow_fallback:
	121	return
	122
b73b14f7 YCH	123	filtered_dict = list(filter(None, [dict_obj.get(k) for k in dict_obj.keys()]))
	124	return filtered_dict[0] if filtered_dict else None
	125
1a83c731 S	126
1a83c731 S	127	class VikiIE(VikiBaseIE):
cb9722cb	128	IE_NAME = 'viki'
53de95da	129	_VALID_URL = r'%s(?:videos\|player)/(?P<id>[0-9]+v)' % VikiBaseIE._VALID_URL_BASE
8e3df9df	130	_TESTS = [{
cb9722cb	131	'url': 'http://www.viki.com/videos/1023585v-heirs-episode-14',
cb9722cb PH	132	'info_dict': {
	133	'id': '1023585v',
	134	'ext': 'mp4',
	135	'title': 'Heirs Episode 14',
	136	'uploader': 'SBS',
	137	'description': 'md5:c4b17b9626dd4b143dcc4d855ba3474e',
	138	'upload_date': '20131121',
	139	'age_limit': 13,
6d88bc37	140	},
cb9722cb	141	'skip': 'Blocked in the US',
8e3df9df	142	}, {
1a83c731	143	# clip
8e3df9df	144	'url': 'http://www.viki.com/videos/1067139v-the-avengers-age-of-ultron-press-conference',
10568217	145	'md5': '86c0b5dbd4d83a6611a79987cc7a1989',
8e3df9df YCH	146	'info_dict': {
	147	'id': '1067139v',
	148	'ext': 'mp4',
1a83c731	149	'title': "'The Avengers: Age of Ultron' Press Conference",
8e3df9df	150	'description': 'md5:d70b2f9428f5488321bfe1db10d612ea',
1a83c731 S	151	'duration': 352,
1a83c731 S	152	'timestamp': 1430380829,
8e3df9df	153	'upload_date': '20150430',
1a83c731 S	154	'uploader': 'Arirang TV',
	155	'like_count': int,
	156	'age_limit': 0,
8e3df9df	157	}
d948e09b YCH	158	}, {
	159	'url': 'http://www.viki.com/videos/1048879v-ankhon-dekhi',
	160	'info_dict': {
	161	'id': '1048879v',
	162	'ext': 'mp4',
d948e09b	163	'title': 'Ankhon Dekhi',
1a83c731 S	164	'duration': 6512,
	165	'timestamp': 1408532356,
	166	'upload_date': '20140820',
	167	'uploader': 'Spuul',
	168	'like_count': int,
	169	'age_limit': 13,
d948e09b	170	},
94e5d6ae	171	'skip': 'Blocked in the US',
1a83c731 S	172	}, {
	173	# episode
	174	'url': 'http://www.viki.com/videos/44699v-boys-over-flowers-episode-1',
a0566bbf	175	'md5': '94e0e34fd58f169f40c184f232356cfe',
1a83c731 S	176	'info_dict': {
	177	'id': '44699v',
	178	'ext': 'mp4',
	179	'title': 'Boys Over Flowers - Episode 1',
c83b35d4	180	'description': 'md5:b89cf50038b480b88b5b3c93589a9076',
a0566bbf	181	'duration': 4172,
1a83c731 S	182	'timestamp': 1270496524,
	183	'upload_date': '20100405',
	184	'uploader': 'group8',
	185	'like_count': int,
	186	'age_limit': 13,
a0566bbf	187	},
a0566bbf	188	'expected_warnings': ['Unknown MIME type image/jpeg in DASH manifest'],
ac20d95f S	189	}, {
	190	# youtube external
	191	'url': 'http://www.viki.com/videos/50562v-poor-nastya-complete-episode-1',
f22ba4bd	192	'md5': '63f8600c1da6f01b7640eee7eca4f1da',
ac20d95f S	193	'info_dict': {
ac20d95f S	194	'id': '50562v',
f22ba4bd	195	'ext': 'webm',
ac20d95f S	196	'title': 'Poor Nastya [COMPLETE] - Episode 1',
ac20d95f S	197	'description': '',
f22ba4bd	198	'duration': 606,
ac20d95f S	199	'timestamp': 1274949505,
	200	'upload_date': '20101213',
	201	'uploader': 'ad14065n',
	202	'uploader_id': 'ad14065n',
	203	'like_count': int,
	204	'age_limit': 13,
a0566bbf	205	},
a0566bbf	206	'skip': 'Page not found!',
1a83c731 S	207	}, {
	208	'url': 'http://www.viki.com/player/44699v',
	209	'only_matching': True,
41597d9b YCH	210	}, {
	211	# non-English description
	212	'url': 'http://www.viki.com/videos/158036v-love-in-magic',
a0566bbf	213	'md5': 'adf9e321a0ae5d0aace349efaaff7691',
41597d9b YCH	214	'info_dict': {
	215	'id': '158036v',
	216	'ext': 'mp4',
	217	'uploader': 'I Planet Entertainment',
	218	'upload_date': '20111122',
	219	'timestamp': 1321985454,
	220	'description': 'md5:44b1e46619df3a072294645c770cef36',
	221	'title': 'Love In Magic',
dc016bf5	222	'age_limit': 13,
41597d9b	223	},
8e3df9df	224	}]
382ed50e PH	225
382ed50e PH	226	def _real_extract(self, url):
8ee34150	227	video_id = self._match_id(url)
382ed50e	228
a0566bbf	229	resp = self._download_json(
a0566bbf	230	'https://www.viki.com/api/videos/' + video_id,
38d70284	231	video_id, 'Downloading video JSON', headers={
	232	'x-client-user-agent': std_headers['User-Agent'],
	233	'x-viki-app-ver': '4.0.57',
	234	})
a0566bbf	235	video = resp['video']
169bd46b	236
dc016bf5	237	self._check_errors(video)
dc016bf5	238
6d28c408	239	title = self.dict_selection(video.get('titles', {}), 'en', allow_fallback=False)
1a83c731 S	240	if not title:
1a83c731 S	241	title = 'Episode %d' % video.get('number') if video.get('type') == 'episode' else video.get('id') or video_id
b73b14f7 YCH	242	container_titles = video.get('container', {}).get('titles', {})
	243	container_title = self.dict_selection(container_titles, 'en')
	244	title = '%s - %s' % (container_title, title)
	245
	246	description = self.dict_selection(video.get('descriptions', {}), 'en')
1a83c731 S	247
	248	duration = int_or_none(video.get('duration'))
	249	timestamp = parse_iso8601(video.get('created_at'))
	250	uploader = video.get('author')
	251	like_count = int_or_none(video.get('likes', {}).get('count'))
	252	age_limit = parse_age_limit(video.get('rating'))
	253
	254	thumbnails = []
	255	for thumbnail_id, thumbnail in video.get('images', {}).items():
	256	thumbnails.append({
	257	'id': thumbnail_id,
	258	'url': thumbnail.get('url'),
	259	})
	260
	261	subtitles = {}
142f2c8e RD	262	try:
	263	# New way to fetch subtitles
	264	new_video = self._download_json(
	265	'https://www.viki.com/api/videos/%s' % video_id, video_id,
29f7c58a	266	'Downloading new video JSON to get subtitles', fatal=False)
142f2c8e RD	267	for sub in new_video.get('streamSubtitles').get('dash'):
	268	subtitles[sub.get('srclang')] = [{
	269	'ext': 'vtt',
	270	'url': sub.get('src'),
	271	'completion': sub.get('percentage'),
	272	}]
	273	except AttributeError:
	274	# fall-back to the old way if there isn't a streamSubtitles attribute
	275	for subtitle_lang, _ in video.get('subtitle_completions', {}).items():
	276	subtitles[subtitle_lang] = [{
	277	'ext': subtitles_format,
	278	'url': self._prepare_call(
	279	'videos/%s/subtitles/%s.%s' % (video_id, subtitle_lang, subtitles_format)),
	280	} for subtitles_format in ('srt', 'vtt')]
382ed50e	281
ac20d95f	282	result = {
382ed50e PH	283	'id': video_id,
382ed50e PH	284	'title': title,
382ed50e	285	'description': description,
1a83c731 S	286	'duration': duration,
1a83c731 S	287	'timestamp': timestamp,
382ed50e	288	'uploader': uploader,
1a83c731 S	289	'like_count': like_count,
	290	'age_limit': age_limit,
	291	'thumbnails': thumbnails,
1a83c731	292	'subtitles': subtitles,
382ed50e PH	293	}
382ed50e PH	294
a0566bbf	295	formats = []
	296
	297	def add_format(format_id, format_dict, protocol='http'):
	298	# rtmps URLs does not seem to work
	299	if protocol == 'rtmps':
	300	return
	301	format_url = format_dict.get('url')
	302	if not format_url:
	303	return
	304	format_drms = format_dict.get('drms')
	305	format_stream_id = format_dict.get('id')
	306	qs = compat_parse_qs(compat_urllib_parse_urlparse(format_url).query)
	307	stream = qs.get('stream', [None])[0]
	308	if stream:
	309	format_url = base64.b64decode(stream).decode()
	310	if format_id in ('m3u8', 'hls'):
	311	m3u8_formats = self._extract_m3u8_formats(
	312	format_url, video_id, 'mp4',
	313	entry_protocol='m3u8_native',
	314	m3u8_id='m3u8-%s' % protocol, fatal=False)
	315	# Despite CODECS metadata in m3u8 all video-only formats
	316	# are actually video+audio
	317	for f in m3u8_formats:
	318	if '_drm/index_' in f['url']:
	319	continue
	320	if f.get('acodec') == 'none' and f.get('vcodec') != 'none':
	321	f['acodec'] = None
	322	formats.append(f)
	323	elif format_id in ('mpd', 'dash'):
	324	formats.extend(self._extract_mpd_formats(
	325	format_url, video_id, 'mpd-%s' % protocol, fatal=False))
	326	elif format_url.startswith('rtmp'):
	327	mobj = re.search(
	328	r'^(?P<url>rtmp://[^/]+/(?P<app>.+?))/(?P<playpath>mp4:.+)$',
	329	format_url)
	330	if not mobj:
	331	return
	332	formats.append({
	333	'format_id': 'rtmp-%s' % format_id,
	334	'ext': 'flv',
	335	'url': mobj.group('url'),
	336	'play_path': mobj.group('playpath'),
	337	'app': mobj.group('app'),
	338	'page_url': url,
	339	'drms': format_drms,
	340	'stream_id': format_stream_id,
	341	})
	342	else:
	343	urlh = self._request_webpage(
	344	HEADRequest(format_url), video_id, 'Checking file size', fatal=False)
	345	formats.append({
	346	'url': format_url,
	347	'format_id': '%s-%s' % (format_id, protocol),
	348	'height': int_or_none(self._search_regex(
	349	r'^(\d+)[pP]$', format_id, 'height', default=None)),
	350	'drms': format_drms,
	351	'stream_id': format_stream_id,
	352	'filesize': int_or_none(urlh.headers.get('Content-Length')),
	353	})
	354
	355	for format_id, format_dict in (resp.get('streams') or {}).items():
	356	add_format(format_id, format_dict)
	357	if not formats:
	358	streams = self._call_api(
359	'videos/%s/streams.json' % video_id, video_id,
360	'Downloading video streams JSON')
361
362	if 'external' in streams:
363	result.update({
364	'_type': 'url_transparent',
365	'url': streams['external']['url'],
366	})
367	return result
368
369	for format_id, stream_dict in streams.items():
370	for protocol, format_dict in stream_dict.items():
371	add_format(format_id, format_dict, protocol)
372	self._sort_formats(formats)
ac20d95f	373
ac20d95f S	374	result['formats'] = formats
	375	return result
	376
0d7f0364	377
bc56355e	378	class VikiChannelIE(VikiBaseIE):
8da0e0e9	379	IE_NAME = 'viki:channel'
53de95da	380	_VALID_URL = r'%s(?:tv\|news\|movies\|artists)/(?P<id>[0-9]+c)' % VikiBaseIE._VALID_URL_BASE
0d7f0364	381	_TESTS = [{
	382	'url': 'http://www.viki.com/tv/50c-boys-over-flowers',
	383	'info_dict': {
	384	'id': '50c',
	385	'title': 'Boys Over Flowers',
	386	'description': 'md5:ecd3cff47967fe193cff37c0bec52790',
	387	},
c83b35d4	388	'playlist_mincount': 71,
1c18de00	389	}, {
	390	'url': 'http://www.viki.com/tv/1354c-poor-nastya-complete',
	391	'info_dict': {
	392	'id': '1354c',
	393	'title': 'Poor Nastya [COMPLETE]',
	394	'description': 'md5:05bf5471385aa8b21c18ad450e350525',
	395	},
	396	'playlist_count': 127,
d01924f4 S	397	}, {
	398	'url': 'http://www.viki.com/news/24569c-showbiz-korea',
	399	'only_matching': True,
	400	}, {
	401	'url': 'http://www.viki.com/movies/22047c-pride-and-prejudice-2005',
	402	'only_matching': True,
	403	}, {
	404	'url': 'http://www.viki.com/artists/2141c-shinee',
	405	'only_matching': True,
0d7f0364	406	}]
bc56355e	407
8da0e0e9	408	_PER_PAGE = 25
0d7f0364	409
0d7f0364	410	def _real_extract(self, url):
b0d619fd	411	channel_id = self._match_id(url)
0d7f0364	412
bc56355e S	413	channel = self._call_api(
	414	'containers/%s.json' % channel_id, channel_id,
	415	'Downloading channel JSON')
b0d619fd	416
dc016bf5	417	self._check_errors(channel)
dc016bf5	418
b73b14f7	419	title = self.dict_selection(channel['titles'], 'en')
b0d619fd	420
b73b14f7	421	description = self.dict_selection(channel['descriptions'], 'en')
0d7f0364	422
0d7f0364	423	entries = []
d01924f4	424	for video_type in ('episodes', 'clips', 'movies'):
bc56355e S	425	for page_num in itertools.count(1):
	426	page = self._call_api(
	427	'containers/%s/%s.json?per_page=%d&sort=number&direction=asc&with_paging=true&page=%d'
	428	% (channel_id, video_type, self._PER_PAGE, page_num), channel_id,
	429	'Downloading %s JSON page #%d' % (video_type, page_num))
b0d619fd	430	for video in page['response']:
1c18de00	431	video_id = video['id']
1c18de00	432	entries.append(self.url_result(
26a87972	433	'https://www.viki.com/videos/%s' % video_id, 'Viki'))
bc56355e S	434	if not page['pagination']['next']:
bc56355e S	435	break
0d7f0364	436
b0d619fd	437	return self.playlist_result(entries, channel_id, title, description)