[yt-dlp.git] / yt_dlp / extractor / sonyliv.py

import datetime
import json
import math
import random
import time
import uuid

from .common import InfoExtractor
from ..compat import compat_HTTPError
from ..utils import (
    ExtractorError,
    int_or_none,
    try_get,
)


class SonyLIVIE(InfoExtractor):
    _VALID_URL = r'''(?x)
                     (?:
                        sonyliv:|
                        https?://(?:www\.)?sonyliv\.com/(?:s(?:how|port)s/[^/]+|movies|clip|trailer|music-videos)/[^/?#&]+-
                    )
                    (?P<id>\d+)
                  '''
    _TESTS = [{
        'url': 'https://www.sonyliv.com/shows/bachelors-delight-1700000113/achaari-cheese-toast-1000022678?watch=true',
        'info_dict': {
            'title': 'Achaari Cheese Toast',
            'id': '1000022678',
            'ext': 'mp4',
            'upload_date': '20200411',
            'description': 'md5:3957fa31d9309bf336ceb3f37ad5b7cb',
            'timestamp': 1586632091,
            'duration': 185,
            'season_number': 1,
            'series': 'Bachelors Delight',
            'episode_number': 1,
            'release_year': 2016,
        },
        'params': {
            'skip_download': True,
        },
    }, {
        'url': 'https://www.sonyliv.com/movies/tahalka-1000050121?watch=true',
        'only_matching': True,
    }, {
        'url': 'https://www.sonyliv.com/clip/jigarbaaz-1000098925',
        'only_matching': True,
    }, {
        'url': 'https://www.sonyliv.com/trailer/sandwiched-forever-1000100286?watch=true',
        'only_matching': True,
    }, {
        'url': 'https://www.sonyliv.com/sports/india-tour-of-australia-2020-21-1700000286/cricket-hls-day-3-1st-test-aus-vs-ind-19-dec-2020-1000100959?watch=true',
        'only_matching': True,
    }, {
        'url': 'https://www.sonyliv.com/music-videos/yeh-un-dinon-ki-baat-hai-1000018779',
        'only_matching': True,
    }]
    _GEO_COUNTRIES = ['IN']
    _HEADERS = {}
    _LOGIN_HINT = 'Use "--username <mobile_number>" to login using OTP or "--username token --password <auth_token>" to login using auth token.'
    _NETRC_MACHINE = 'sonyliv'

    def _get_device_id(self):
        e = int(time.time() * 1000)
        t = list('xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx')
        for i, c in enumerate(t):
            n = int((e + 16 * random.random()) % 16) | 0
            e = math.floor(e / 16)
            if c == 'x':
                t[i] = str(n)
            elif c == 'y':
                t[i] = '{:x}'.format(3 & n | 8)
        return ''.join(t) + '-' + str(int(time.time() * 1000))

    def _perform_login(self, username, password):
        self._HEADERS['device_id'] = self._get_device_id()
        self._HEADERS['content-type'] = 'application/json'

        if username.lower() == 'token' and len(password) > 1198:
            self._HEADERS['authorization'] = password
        elif len(username) != 10 or not username.isdigit():
            raise ExtractorError(f'Invalid username/password; {self._LOGIN_HINT}')

        self.report_login()
        otp_request_json = self._download_json(
            'https://apiv2.sonyliv.com/AGL/1.6/A/ENG/WEB/IN/HR/CREATEOTP-V2',
            None, note='Sending OTP', headers=self._HEADERS, data=json.dumps({
                'mobileNumber': username,
                'channelPartnerID': 'MSMIND',
                'country': 'IN',
                'timestamp': datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%MZ'),
                'otpSize': 6,
                'loginType': 'REGISTERORSIGNIN',
                'isMobileMandatory': True,
            }).encode())
        if otp_request_json['resultCode'] == 'KO':
            raise ExtractorError(otp_request_json['message'], expected=True)

        otp_verify_json = self._download_json(
            'https://apiv2.sonyliv.com/AGL/2.0/A/ENG/WEB/IN/HR/CONFIRMOTP-V2',
            None, note='Verifying OTP', headers=self._HEADERS, data=json.dumps({
                'channelPartnerID': 'MSMIND',
                'mobileNumber': username,
                'country': 'IN',
                'otp': self._get_tfa_info('OTP'),
                'dmaId': 'IN',
                'ageConfirmation': True,
                'timestamp': datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%MZ'),
                'isMobileMandatory': True,
            }).encode())
        if otp_verify_json['resultCode'] == 'KO':
            raise ExtractorError(otp_request_json['message'], expected=True)
        self._HEADERS['authorization'] = otp_verify_json['resultObj']['accessToken']

    def _call_api(self, version, path, video_id):
        try:
            return self._download_json(
                'https://apiv2.sonyliv.com/AGL/%s/A/ENG/WEB/%s' % (version, path),
                video_id, headers=self._HEADERS)['resultObj']
        except ExtractorError as e:
            if isinstance(e.cause, compat_HTTPError) and e.cause.code == 406 and self._parse_json(
                    e.cause.read().decode(), video_id)['message'] == 'Please subscribe to watch this content':
                self.raise_login_required(self._LOGIN_HINT, method=None)
            if isinstance(e.cause, compat_HTTPError) and e.cause.code == 403:
                message = self._parse_json(
                    e.cause.read().decode(), video_id)['message']
                if message == 'Geoblocked Country':
                    self.raise_geo_restricted(countries=self._GEO_COUNTRIES)
                raise ExtractorError(message)
            raise

    def _initialize_pre_login(self):
        self._HEADERS['security_token'] = self._call_api('1.4', 'ALL/GETTOKEN', None)

    def _real_extract(self, url):
        video_id = self._match_id(url)
        content = self._call_api(
            '1.5', 'IN/CONTENT/VIDEOURL/VOD/' + video_id, video_id)
        if not self.get_param('allow_unplayable_formats') and content.get('isEncrypted'):
            self.report_drm(video_id)
        dash_url = content['videoURL']
        headers = {
            'x-playback-session-id': '%s-%d' % (uuid.uuid4().hex, time.time() * 1000)
        }
        formats = self._extract_mpd_formats(
            dash_url, video_id, mpd_id='dash', headers=headers, fatal=False)
        formats.extend(self._extract_m3u8_formats(
            dash_url.replace('.mpd', '.m3u8').replace('/DASH/', '/HLS/'),
            video_id, 'mp4', m3u8_id='hls', headers=headers, fatal=False))
        for f in formats:
            f.setdefault('http_headers', {}).update(headers)

        metadata = self._call_api(
            '1.6', 'IN/DETAIL/' + video_id, video_id)['containers'][0]['metadata']
        title = metadata['episodeTitle']
        subtitles = {}
        for sub in content.get('subtitle', []):
            sub_url = sub.get('subtitleUrl')
            if not sub_url:
                continue
            subtitles.setdefault(sub.get('subtitleLanguageName', 'ENG'), []).append({
                'url': sub_url,
            })
        return {
            'id': video_id,
            'title': title,
            'formats': formats,
            'thumbnail': content.get('posterURL'),
            'description': metadata.get('longDescription') or metadata.get('shortDescription'),
            'timestamp': int_or_none(metadata.get('creationDate'), 1000),
            'duration': int_or_none(metadata.get('duration')),
            'season_number': int_or_none(metadata.get('season')),
            'series': metadata.get('title'),
            'episode_number': int_or_none(metadata.get('episodeNumber')),
            'release_year': int_or_none(metadata.get('year')),
            'subtitles': subtitles,
        }


class SonyLIVSeriesIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?sonyliv\.com/shows/[^/?#&]+-(?P<id>\d{10})$'
    _TESTS = [{
        'url': 'https://www.sonyliv.com/shows/adaalat-1700000091',
        'playlist_mincount': 456,
        'info_dict': {
            'id': '1700000091',
        },
    }]
    _API_SHOW_URL = "https://apiv2.sonyliv.com/AGL/1.9/R/ENG/WEB/IN/DL/DETAIL/{}?kids_safe=false&from=0&to=49"
    _API_EPISODES_URL = "https://apiv2.sonyliv.com/AGL/1.4/R/ENG/WEB/IN/CONTENT/DETAIL/BUNDLE/{}?from=0&to=1000&orderBy=episodeNumber&sortOrder=asc"
    _API_SECURITY_URL = 'https://apiv2.sonyliv.com/AGL/1.4/A/ENG/WEB/ALL/GETTOKEN'

    def _entries(self, show_id):
        headers = {
            'Accept': 'application/json, text/plain, */*',
            'Referer': 'https://www.sonyliv.com',
        }
        headers['security_token'] = self._download_json(
            self._API_SECURITY_URL, video_id=show_id, headers=headers,
            note='Downloading security token')['resultObj']
        seasons = try_get(
            self._download_json(self._API_SHOW_URL.format(show_id), video_id=show_id, headers=headers),
            lambda x: x['resultObj']['containers'][0]['containers'], list)
        for season in seasons or []:
            season_id = season['id']
            episodes = try_get(
                self._download_json(self._API_EPISODES_URL.format(season_id), video_id=season_id, headers=headers),
                lambda x: x['resultObj']['containers'][0]['containers'], list)
            for episode in episodes or []:
                video_id = episode.get('id')
                yield self.url_result('sonyliv:%s' % video_id, ie=SonyLIVIE.ie_key(), video_id=video_id)

    def _real_extract(self, url):
        show_id = self._match_id(url)
        return self.playlist_result(self._entries(show_id), playlist_id=show_id)
Commit	Line	Data
db77c49c	1	import datetime
e5a998f3	2	import json
db77c49c AG	3	import math
db77c49c AG	4	import random
29f7c58a	5	import time
	6	import uuid
	7
8991844e	8	from .common import InfoExtractor
29f7c58a	9	from ..compat import compat_HTTPError
	10	from ..utils import (
	11	ExtractorError,
	12	int_or_none,
135e6b93	13	try_get,
29f7c58a	14	)
8991844e SS	15
	16
	17	class SonyLIVIE(InfoExtractor):
135e6b93 A	18	_VALID_URL = r'''(?x)
	19	(?:
	20	sonyliv:\|
	21	https?://(?:www\.)?sonyliv\.com/(?:s(?:how\|port)s/[^/]+\|movies\|clip\|trailer\|music-videos)/[^/?#&]+-
	22	)
	23	(?P<id>\d+)
	24	'''
77426a08	25	_TESTS = [{
29f7c58a	26	'url': 'https://www.sonyliv.com/shows/bachelors-delight-1700000113/achaari-cheese-toast-1000022678?watch=true',
8991844e	27	'info_dict': {
c28cfda8	28	'title': 'Achaari Cheese Toast',
29f7c58a	29	'id': '1000022678',
8991844e	30	'ext': 'mp4',
29f7c58a	31	'upload_date': '20200411',
	32	'description': 'md5:3957fa31d9309bf336ceb3f37ad5b7cb',
	33	'timestamp': 1586632091,
	34	'duration': 185,
	35	'season_number': 1,
c28cfda8	36	'series': 'Bachelors Delight',
29f7c58a	37	'episode_number': 1,
29f7c58a	38	'release_year': 2016,
8991844e SS	39	},
	40	'params': {
	41	'skip_download': True,
	42	},
77426a08	43	}, {
29f7c58a	44	'url': 'https://www.sonyliv.com/movies/tahalka-1000050121?watch=true',
	45	'only_matching': True,
	46	}, {
	47	'url': 'https://www.sonyliv.com/clip/jigarbaaz-1000098925',
	48	'only_matching': True,
	49	}, {
	50	'url': 'https://www.sonyliv.com/trailer/sandwiched-forever-1000100286?watch=true',
	51	'only_matching': True,
	52	}, {
	53	'url': 'https://www.sonyliv.com/sports/india-tour-of-australia-2020-21-1700000286/cricket-hls-day-3-1st-test-aus-vs-ind-19-dec-2020-1000100959?watch=true',
	54	'only_matching': True,
	55	}, {
	56	'url': 'https://www.sonyliv.com/music-videos/yeh-un-dinon-ki-baat-hai-1000018779',
77426a08 S	57	'only_matching': True,
77426a08 S	58	}]
29f7c58a	59	_GEO_COUNTRIES = ['IN']
db77c49c AG	60	_HEADERS = {}
	61	_LOGIN_HINT = 'Use "--username <mobile_number>" to login using OTP or "--username token --password <auth_token>" to login using auth token.'
	62	_NETRC_MACHINE = 'sonyliv'
	63
	64	def _get_device_id(self):
	65	e = int(time.time() * 1000)
	66	t = list('xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx')
	67	for i, c in enumerate(t):
	68	n = int((e + 16 * random.random()) % 16) \| 0
	69	e = math.floor(e / 16)
	70	if c == 'x':
	71	t[i] = str(n)
	72	elif c == 'y':
	73	t[i] = '{:x}'.format(3 & n \| 8)
	74	return ''.join(t) + '-' + str(int(time.time() * 1000))
	75
52efa4b3	76	def _perform_login(self, username, password):
	77	self._HEADERS['device_id'] = self._get_device_id()
	78	self._HEADERS['content-type'] = 'application/json'
	79
db77c49c	80	if username.lower() == 'token' and len(password) > 1198:
52efa4b3	81	self._HEADERS['authorization'] = password
db77c49c AG	82	elif len(username) != 10 or not username.isdigit():
	83	raise ExtractorError(f'Invalid username/password; {self._LOGIN_HINT}')
	84
	85	self.report_login()
db77c49c AG	86	otp_request_json = self._download_json(
db77c49c AG	87	'https://apiv2.sonyliv.com/AGL/1.6/A/ENG/WEB/IN/HR/CREATEOTP-V2',
e5a998f3	88	None, note='Sending OTP', headers=self._HEADERS, data=json.dumps({
	89	'mobileNumber': username,
	90	'channelPartnerID': 'MSMIND',
	91	'country': 'IN',
	92	'timestamp': datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%MZ'),
	93	'otpSize': 6,
	94	'loginType': 'REGISTERORSIGNIN',
	95	'isMobileMandatory': True,
	96	}).encode())
db77c49c AG	97	if otp_request_json['resultCode'] == 'KO':
db77c49c AG	98	raise ExtractorError(otp_request_json['message'], expected=True)
e5a998f3	99
db77c49c AG	100	otp_verify_json = self._download_json(
db77c49c AG	101	'https://apiv2.sonyliv.com/AGL/2.0/A/ENG/WEB/IN/HR/CONFIRMOTP-V2',
e5a998f3	102	None, note='Verifying OTP', headers=self._HEADERS, data=json.dumps({
	103	'channelPartnerID': 'MSMIND',
	104	'mobileNumber': username,
	105	'country': 'IN',
	106	'otp': self._get_tfa_info('OTP'),
	107	'dmaId': 'IN',
	108	'ageConfirmation': True,
	109	'timestamp': datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%MZ'),
	110	'isMobileMandatory': True,
	111	}).encode())
db77c49c AG	112	if otp_verify_json['resultCode'] == 'KO':
db77c49c AG	113	raise ExtractorError(otp_request_json['message'], expected=True)
52efa4b3	114	self._HEADERS['authorization'] = otp_verify_json['resultObj']['accessToken']
77426a08	115
29f7c58a	116	def _call_api(self, version, path, video_id):
29f7c58a	117	try:
	118	return self._download_json(
	119	'https://apiv2.sonyliv.com/AGL/%s/A/ENG/WEB/%s' % (version, path),
db77c49c	120	video_id, headers=self._HEADERS)['resultObj']
29f7c58a	121	except ExtractorError as e:
db77c49c AG	122	if isinstance(e.cause, compat_HTTPError) and e.cause.code == 406 and self._parse_json(
	123	e.cause.read().decode(), video_id)['message'] == 'Please subscribe to watch this content':
	124	self.raise_login_required(self._LOGIN_HINT, method=None)
29f7c58a	125	if isinstance(e.cause, compat_HTTPError) and e.cause.code == 403:
	126	message = self._parse_json(
	127	e.cause.read().decode(), video_id)['message']
	128	if message == 'Geoblocked Country':
	129	self.raise_geo_restricted(countries=self._GEO_COUNTRIES)
	130	raise ExtractorError(message)
	131	raise
	132
52efa4b3	133	def _initialize_pre_login(self):
db77c49c	134	self._HEADERS['security_token'] = self._call_api('1.4', 'ALL/GETTOKEN', None)
8991844e SS	135
8991844e SS	136	def _real_extract(self, url):
29f7c58a	137	video_id = self._match_id(url)
	138	content = self._call_api(
	139	'1.5', 'IN/CONTENT/VIDEOURL/VOD/' + video_id, video_id)
a06916d9	140	if not self.get_param('allow_unplayable_formats') and content.get('isEncrypted'):
88acdbc2	141	self.report_drm(video_id)
29f7c58a	142	dash_url = content['videoURL']
	143	headers = {
	144	'x-playback-session-id': '%s-%d' % (uuid.uuid4().hex, time.time() * 1000)
	145	}
	146	formats = self._extract_mpd_formats(
	147	dash_url, video_id, mpd_id='dash', headers=headers, fatal=False)
	148	formats.extend(self._extract_m3u8_formats(
	149	dash_url.replace('.mpd', '.m3u8').replace('/DASH/', '/HLS/'),
	150	video_id, 'mp4', m3u8_id='hls', headers=headers, fatal=False))
	151	for f in formats:
	152	f.setdefault('http_headers', {}).update(headers)
29f7c58a	153
	154	metadata = self._call_api(
	155	'1.6', 'IN/DETAIL/' + video_id, video_id)['containers'][0]['metadata']
c28cfda8	156	title = metadata['episodeTitle']
09d18ad0 A	157	subtitles = {}
	158	for sub in content.get('subtitle', []):
	159	sub_url = sub.get('subtitleUrl')
	160	if not sub_url:
	161	continue
	162	subtitles.setdefault(sub.get('subtitleLanguageName', 'ENG'), []).append({
	163	'url': sub_url,
	164	})
29f7c58a	165	return {
	166	'id': video_id,
	167	'title': title,
	168	'formats': formats,
	169	'thumbnail': content.get('posterURL'),
	170	'description': metadata.get('longDescription') or metadata.get('shortDescription'),
	171	'timestamp': int_or_none(metadata.get('creationDate'), 1000),
	172	'duration': int_or_none(metadata.get('duration')),
	173	'season_number': int_or_none(metadata.get('season')),
c28cfda8	174	'series': metadata.get('title'),
29f7c58a	175	'episode_number': int_or_none(metadata.get('episodeNumber')),
29f7c58a	176	'release_year': int_or_none(metadata.get('year')),
09d18ad0	177	'subtitles': subtitles,
29f7c58a	178	}
135e6b93 A	179
	180
	181	class SonyLIVSeriesIE(InfoExtractor):
	182	_VALID_URL = r'https?://(?:www\.)?sonyliv\.com/shows/[^/?#&]+-(?P<id>\d{10})$'
	183	_TESTS = [{
	184	'url': 'https://www.sonyliv.com/shows/adaalat-1700000091',
	185	'playlist_mincount': 456,
	186	'info_dict': {
	187	'id': '1700000091',
	188	},
	189	}]
	190	_API_SHOW_URL = "https://apiv2.sonyliv.com/AGL/1.9/R/ENG/WEB/IN/DL/DETAIL/{}?kids_safe=false&from=0&to=49"
	191	_API_EPISODES_URL = "https://apiv2.sonyliv.com/AGL/1.4/R/ENG/WEB/IN/CONTENT/DETAIL/BUNDLE/{}?from=0&to=1000&orderBy=episodeNumber&sortOrder=asc"
	192	_API_SECURITY_URL = 'https://apiv2.sonyliv.com/AGL/1.4/A/ENG/WEB/ALL/GETTOKEN'
	193
	194	def _entries(self, show_id):
	195	headers = {
	196	'Accept': 'application/json, text/plain, /',
	197	'Referer': 'https://www.sonyliv.com',
	198	}
	199	headers['security_token'] = self._download_json(
	200	self._API_SECURITY_URL, video_id=show_id, headers=headers,
	201	note='Downloading security token')['resultObj']
	202	seasons = try_get(
	203	self._download_json(self._API_SHOW_URL.format(show_id), video_id=show_id, headers=headers),
	204	lambda x: x['resultObj']['containers'][0]['containers'], list)
	205	for season in seasons or []:
	206	season_id = season['id']
	207	episodes = try_get(
	208	self._download_json(self._API_EPISODES_URL.format(season_id), video_id=season_id, headers=headers),
	209	lambda x: x['resultObj']['containers'][0]['containers'], list)
	210	for episode in episodes or []:
	211	video_id = episode.get('id')
	212	yield self.url_result('sonyliv:%s' % video_id, ie=SonyLIVIE.ie_key(), video_id=video_id)
	213
	214	def _real_extract(self, url):
	215	show_id = self._match_id(url)
	216	return self.playlist_result(self._entries(show_id), playlist_id=show_id)