[yt-dlp.git] / youtube_dl / extractor / lynda.py

from __future__ import unicode_literals

import re

from .common import InfoExtractor
from ..compat import (
    compat_HTTPError,
    compat_str,
    compat_urlparse,
)
from ..utils import (
    ExtractorError,
    int_or_none,
    urlencode_postdata,
)


class LyndaBaseIE(InfoExtractor):
    _SIGNIN_URL = 'https://www.lynda.com/signin'
    _PASSWORD_URL = 'https://www.lynda.com/signin/password'
    _USER_URL = 'https://www.lynda.com/signin/user'
    _ACCOUNT_CREDENTIALS_HINT = 'Use --username and --password options to provide lynda.com account credentials.'
    _NETRC_MACHINE = 'lynda'

    def _real_initialize(self):
        self._login()

    @staticmethod
    def _check_error(json_string, key_or_keys):
        keys = [key_or_keys] if isinstance(key_or_keys, compat_str) else key_or_keys
        for key in keys:
            error = json_string.get(key)
            if error:
                raise ExtractorError('Unable to login: %s' % error, expected=True)

    def _login_step(self, form_html, fallback_action_url, extra_form_data, note, referrer_url):
        action_url = self._search_regex(
            r'<form[^>]+action=(["\'])(?P<url>.+?)\1', form_html,
            'post url', default=fallback_action_url, group='url')

        if not action_url.startswith('http'):
            action_url = compat_urlparse.urljoin(self._SIGNIN_URL, action_url)

        form_data = self._hidden_inputs(form_html)
        form_data.update(extra_form_data)

        try:
            response = self._download_json(
                action_url, None, note,
                data=urlencode_postdata(form_data),
                headers={
                    'Referer': referrer_url,
                    'X-Requested-With': 'XMLHttpRequest',
                })
        except ExtractorError as e:
            if isinstance(e.cause, compat_HTTPError) and e.cause.code == 500:
                response = self._parse_json(e.cause.read().decode('utf-8'), None)
                self._check_error(response, ('email', 'password'))
            raise

        self._check_error(response, 'ErrorMessage')

        return response, action_url

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

        # Step 1: download signin page
        signin_page = self._download_webpage(
            self._SIGNIN_URL, None, 'Downloading signin page')

        # Already logged in
        if any(re.search(p, signin_page) for p in (
                r'isLoggedIn\s*:\s*true', r'logout\.aspx', r'>Log out<')):
            return

        # Step 2: submit email
        signin_form = self._search_regex(
            r'(?s)(<form[^>]+data-form-name=["\']signin["\'][^>]*>.+?</form>)',
            signin_page, 'signin form')
        signin_page, signin_url = self._login_step(
            signin_form, self._PASSWORD_URL, {'email': username},
            'Submitting email', self._SIGNIN_URL)

        # Step 3: submit password
        password_form = signin_page['body']
        self._login_step(
            password_form, self._USER_URL, {'email': username, 'password': password},
            'Submitting password', signin_url)


class LyndaIE(LyndaBaseIE):
    IE_NAME = 'lynda'
    IE_DESC = 'lynda.com videos'
    _VALID_URL = r'''(?x)
                    https?://
                        (?:www\.)?(?:lynda\.com|educourse\.ga)/
                        (?:
                            (?:[^/]+/){2,3}(?P<course_id>\d+)|
                            player/embed
                        )/
                        (?P<id>\d+)
                    '''

    _TIMECODE_REGEX = r'\[(?P<timecode>\d+:\d+:\d+[\.,]\d+)\]'

    _TESTS = [{
        'url': 'https://www.lynda.com/Bootstrap-tutorials/Using-exercise-files/110885/114408-4.html',
        # md5 is unstable
        'info_dict': {
            'id': '114408',
            'ext': 'mp4',
            'title': 'Using the exercise files',
            'duration': 68
        }
    }, {
        'url': 'https://www.lynda.com/player/embed/133770?tr=foo=1;bar=g;fizz=rt&fs=0',
        'only_matching': True,
    }, {
        'url': 'https://educourse.ga/Bootstrap-tutorials/Using-exercise-files/110885/114408-4.html',
        'only_matching': True,
    }, {
        'url': 'https://www.lynda.com/de/Graphic-Design-tutorials/Willkommen-Grundlagen-guten-Gestaltung/393570/393572-4.html',
        'only_matching': True,
    }]

    def _raise_unavailable(self, video_id):
        self.raise_login_required(
            'Video %s is only available for members' % video_id)

    def _real_extract(self, url):
        mobj = re.match(self._VALID_URL, url)
        video_id = mobj.group('id')
        course_id = mobj.group('course_id')

        query = {
            'videoId': video_id,
            'type': 'video',
        }

        video = self._download_json(
            'https://www.lynda.com/ajax/player', video_id,
            'Downloading video JSON', fatal=False, query=query)

        # Fallback scenario
        if not video:
            query['courseId'] = course_id

            play = self._download_json(
                'https://www.lynda.com/ajax/course/%s/%s/play'
                % (course_id, video_id), video_id, 'Downloading play JSON')

            if not play:
                self._raise_unavailable(video_id)

            formats = []
            for formats_dict in play:
                urls = formats_dict.get('urls')
                if not isinstance(urls, dict):
                    continue
                cdn = formats_dict.get('name')
                for format_id, format_url in urls.items():
                    if not format_url:
                        continue
                    formats.append({
                        'url': format_url,
                        'format_id': '%s-%s' % (cdn, format_id) if cdn else format_id,
                        'height': int_or_none(format_id),
                    })
            self._sort_formats(formats)

            conviva = self._download_json(
                'https://www.lynda.com/ajax/player/conviva', video_id,
                'Downloading conviva JSON', query=query)

            return {
                'id': video_id,
                'title': conviva['VideoTitle'],
                'description': conviva.get('VideoDescription'),
                'release_year': int_or_none(conviva.get('ReleaseYear')),
                'duration': int_or_none(conviva.get('Duration')),
                'creator': conviva.get('Author'),
                'formats': formats,
            }

        if 'Status' in video:
            raise ExtractorError(
                'lynda returned error: %s' % video['Message'], expected=True)

        if video.get('HasAccess') is False:
            self._raise_unavailable(video_id)

        video_id = compat_str(video.get('ID') or video_id)
        duration = int_or_none(video.get('DurationInSeconds'))
        title = video['Title']

        formats = []

        fmts = video.get('Formats')
        if fmts:
            formats.extend([{
                'url': f['Url'],
                'ext': f.get('Extension'),
                'width': int_or_none(f.get('Width')),
                'height': int_or_none(f.get('Height')),
                'filesize': int_or_none(f.get('FileSize')),
                'format_id': compat_str(f.get('Resolution')) if f.get('Resolution') else None,
            } for f in fmts if f.get('Url')])

        prioritized_streams = video.get('PrioritizedStreams')
        if prioritized_streams:
            for prioritized_stream_id, prioritized_stream in prioritized_streams.items():
                formats.extend([{
                    'url': video_url,
                    'height': int_or_none(format_id),
                    'format_id': '%s-%s' % (prioritized_stream_id, format_id),
                } for format_id, video_url in prioritized_stream.items()])

        self._check_formats(formats, video_id)
        self._sort_formats(formats)

        subtitles = self.extract_subtitles(video_id)

        return {
            'id': video_id,
            'title': title,
            'duration': duration,
            'subtitles': subtitles,
            'formats': formats
        }

    def _fix_subtitles(self, subs):
        srt = ''
        seq_counter = 0
        for pos in range(0, len(subs) - 1):
            seq_current = subs[pos]
            m_current = re.match(self._TIMECODE_REGEX, seq_current['Timecode'])
            if m_current is None:
                continue
            seq_next = subs[pos + 1]
            m_next = re.match(self._TIMECODE_REGEX, seq_next['Timecode'])
            if m_next is None:
                continue
            appear_time = m_current.group('timecode')
            disappear_time = m_next.group('timecode')
            text = seq_current['Caption'].strip()
            if text:
                seq_counter += 1
                srt += '%s\r\n%s --> %s\r\n%s\r\n\r\n' % (seq_counter, appear_time, disappear_time, text)
        if srt:
            return srt

    def _get_subtitles(self, video_id):
        url = 'https://www.lynda.com/ajax/player?videoId=%s&type=transcript' % video_id
        subs = self._download_json(url, None, False)
        fixed_subs = self._fix_subtitles(subs)
        if fixed_subs:
            return {'en': [{'ext': 'srt', 'data': fixed_subs}]}
        else:
            return {}


class LyndaCourseIE(LyndaBaseIE):
    IE_NAME = 'lynda:course'
    IE_DESC = 'lynda.com online courses'

    # Course link equals to welcome/introduction video link of same course
    # We will recognize it as course link
    _VALID_URL = r'https?://(?:www|m)\.(?:lynda\.com|educourse\.ga)/(?P<coursepath>(?:[^/]+/){2,3}(?P<courseid>\d+))-2\.html'

    _TESTS = [{
        'url': 'https://www.lynda.com/Graphic-Design-tutorials/Grundlagen-guten-Gestaltung/393570-2.html',
        'only_matching': True,
    }, {
        'url': 'https://www.lynda.com/de/Graphic-Design-tutorials/Grundlagen-guten-Gestaltung/393570-2.html',
        'only_matching': True,
    }]

    def _real_extract(self, url):
        mobj = re.match(self._VALID_URL, url)
        course_path = mobj.group('coursepath')
        course_id = mobj.group('courseid')

        item_template = 'https://www.lynda.com/%s/%%s-4.html' % course_path

        course = self._download_json(
            'https://www.lynda.com/ajax/player?courseId=%s&type=course' % course_id,
            course_id, 'Downloading course JSON', fatal=False)

        if not course:
            webpage = self._download_webpage(url, course_id)
            entries = [
                self.url_result(
                    item_template % video_id, ie=LyndaIE.ie_key(),
                    video_id=video_id)
                for video_id in re.findall(
                    r'data-video-id=["\'](\d+)', webpage)]
            return self.playlist_result(
                entries, course_id,
                self._og_search_title(webpage, fatal=False),
                self._og_search_description(webpage))

        if course.get('Status') == 'NotFound':
            raise ExtractorError(
                'Course %s does not exist' % course_id, expected=True)

        unaccessible_videos = 0
        entries = []

        # Might want to extract videos right here from video['Formats'] as it seems 'Formats' is not provided
        # by single video API anymore

        for chapter in course['Chapters']:
            for video in chapter.get('Videos', []):
                if video.get('HasAccess') is False:
                    unaccessible_videos += 1
                    continue
                video_id = video.get('ID')
                if video_id:
                    entries.append({
                        '_type': 'url_transparent',
                        'url': item_template % video_id,
                        'ie_key': LyndaIE.ie_key(),
                        'chapter': chapter.get('Title'),
                        'chapter_number': int_or_none(chapter.get('ChapterIndex')),
                        'chapter_id': compat_str(chapter.get('ID')),
                    })

        if unaccessible_videos > 0:
            self._downloader.report_warning(
                '%s videos are only available for members (or paid members) and will not be downloaded. '
                % unaccessible_videos + self._ACCOUNT_CREDENTIALS_HINT)

        course_title = course.get('Title')
        course_description = course.get('Description')

        return self.playlist_result(entries, course_id, course_title, course_description)
Commit	Line	Data
a7c26e73 PH	1	from __future__ import unicode_literals
a7c26e73 PH	2
c7f8537d	3	import re
c7f8537d	4
c7f8537d	5	from .common import InfoExtractor
bdf16f81 S	6	from ..compat import (
	7	compat_HTTPError,
	8	compat_str,
	9	compat_urlparse,
	10	)
1cc79574	11	from ..utils import (
16ff7ebc S	12	ExtractorError,
16ff7ebc S	13	int_or_none,
6e6bc8da	14	urlencode_postdata,
7ee40b5d	15	)
c7f8537d	16
c7f8537d	17
30cbd4e0	18	class LyndaBaseIE(InfoExtractor):
bdf16f81 S	19	_SIGNIN_URL = 'https://www.lynda.com/signin'
	20	_PASSWORD_URL = 'https://www.lynda.com/signin/password'
	21	_USER_URL = 'https://www.lynda.com/signin/user'
30cbd4e0	22	_ACCOUNT_CREDENTIALS_HINT = 'Use --username and --password options to provide lynda.com account credentials.'
499bfcbf	23	_NETRC_MACHINE = 'lynda'
30cbd4e0 S	24
	25	def _real_initialize(self):
	26	self._login()
	27
bdf16f81 S	28	@staticmethod
	29	def _check_error(json_string, key_or_keys):
	30	keys = [key_or_keys] if isinstance(key_or_keys, compat_str) else key_or_keys
	31	for key in keys:
	32	error = json_string.get(key)
	33	if error:
	34	raise ExtractorError('Unable to login: %s' % error, expected=True)
	35
	36	def _login_step(self, form_html, fallback_action_url, extra_form_data, note, referrer_url):
	37	action_url = self._search_regex(
	38	r'<form[^>]+action=(["\'])(?P<url>.+?)\1', form_html,
	39	'post url', default=fallback_action_url, group='url')
	40
	41	if not action_url.startswith('http'):
	42	action_url = compat_urlparse.urljoin(self._SIGNIN_URL, action_url)
	43
	44	form_data = self._hidden_inputs(form_html)
	45	form_data.update(extra_form_data)
	46
	47	try:
	48	response = self._download_json(
	49	action_url, None, note,
	50	data=urlencode_postdata(form_data),
	51	headers={
	52	'Referer': referrer_url,
	53	'X-Requested-With': 'XMLHttpRequest',
	54	})
	55	except ExtractorError as e:
	56	if isinstance(e.cause, compat_HTTPError) and e.cause.code == 500:
	57	response = self._parse_json(e.cause.read().decode('utf-8'), None)
	58	self._check_error(response, ('email', 'password'))
	59	raise
	60
	61	self._check_error(response, 'ErrorMessage')
	62
	63	return response, action_url
	64
30cbd4e0	65	def _login(self):
0d85c3a7	66	username, password = self._get_login_info()
30cbd4e0 S	67	if username is None:
	68	return
	69
bdf16f81 S	70	# Step 1: download signin page
	71	signin_page = self._download_webpage(
	72	self._SIGNIN_URL, None, 'Downloading signin page')
	73
3841256c S	74	# Already logged in
3841256c S	75	if any(re.search(p, signin_page) for p in (
ec85ded8	76	r'isLoggedIn\s:\strue', r'logout\.aspx', r'>Log out<')):
3841256c S	77	return
3841256c S	78
bdf16f81 S	79	# Step 2: submit email
	80	signin_form = self._search_regex(
	81	r'(?s)(<form[^>]+data-form-name=["\']signin["\'][^>]*>.+?</form>)',
	82	signin_page, 'signin form')
	83	signin_page, signin_url = self._login_step(
	84	signin_form, self._PASSWORD_URL, {'email': username},
	85	'Submitting email', self._SIGNIN_URL)
	86
	87	# Step 3: submit password
	88	password_form = signin_page['body']
	89	self._login_step(
	90	password_form, self._USER_URL, {'email': username, 'password': password},
	91	'Submitting password', signin_url)
30cbd4e0 S	92
	93
	94	class LyndaIE(LyndaBaseIE):
a7c26e73 PH	95	IE_NAME = 'lynda'
a7c26e73 PH	96	IE_DESC = 'lynda.com videos'
b7c74c04 S	97	_VALID_URL = r'''(?x)
	98	https?://
	99	(?:www\.)?(?:lynda\.com\|educourse\.ga)/
	100	(?:
	101	(?:[^/]+/){2,3}(?P<course_id>\d+)\|
	102	player/embed
	103	)/
	104	(?P<id>\d+)
	105	'''
7ee40b5d	106
7ee40b5d	107	_TIMECODE_REGEX = r'\[(?P<timecode>\d+:\d+:\d+[\.,]\d+)\]'
7ee40b5d	108
a0d64613	109	_TESTS = [{
68d9561c	110	'url': 'https://www.lynda.com/Bootstrap-tutorials/Using-exercise-files/110885/114408-4.html',
61a98b86	111	# md5 is unstable
ac260dd8	112	'info_dict': {
136db788 S	113	'id': '114408',
136db788 S	114	'ext': 'mp4',
a7c26e73 PH	115	'title': 'Using the exercise files',
a7c26e73 PH	116	'duration': 68
c7f8537d	117	}
a0d64613 S	118	}, {
	119	'url': 'https://www.lynda.com/player/embed/133770?tr=foo=1;bar=g;fizz=rt&fs=0',
	120	'only_matching': True,
8c6919e4 S	121	}, {
	122	'url': 'https://educourse.ga/Bootstrap-tutorials/Using-exercise-files/110885/114408-4.html',
	123	'only_matching': True,
b7c74c04 S	124	}, {
	125	'url': 'https://www.lynda.com/de/Graphic-Design-tutorials/Willkommen-Grundlagen-guten-Gestaltung/393570/393572-4.html',
	126	'only_matching': True,
a0d64613	127	}]
7ee40b5d	128
6edfc40a S	129	def _raise_unavailable(self, video_id):
	130	self.raise_login_required(
	131	'Video %s is only available for members' % video_id)
	132
c7f8537d	133	def _real_extract(self, url):
6edfc40a S	134	mobj = re.match(self._VALID_URL, url)
	135	video_id = mobj.group('id')
	136	course_id = mobj.group('course_id')
	137
	138	query = {
	139	'videoId': video_id,
	140	'type': 'video',
	141	}
c7f8537d	142
ea8ed40b	143	video = self._download_json(
6edfc40a S	144	'https://www.lynda.com/ajax/player', video_id,
	145	'Downloading video JSON', fatal=False, query=query)
	146
	147	# Fallback scenario
	148	if not video:
	149	query['courseId'] = course_id
	150
	151	play = self._download_json(
	152	'https://www.lynda.com/ajax/course/%s/%s/play'
	153	% (course_id, video_id), video_id, 'Downloading play JSON')
	154
	155	if not play:
	156	self._raise_unavailable(video_id)
	157
	158	formats = []
	159	for formats_dict in play:
	160	urls = formats_dict.get('urls')
	161	if not isinstance(urls, dict):
	162	continue
	163	cdn = formats_dict.get('name')
	164	for format_id, format_url in urls.items():
	165	if not format_url:
	166	continue
	167	formats.append({
	168	'url': format_url,
	169	'format_id': '%s-%s' % (cdn, format_id) if cdn else format_id,
	170	'height': int_or_none(format_id),
	171	})
	172	self._sort_formats(formats)
	173
	174	conviva = self._download_json(
	175	'https://www.lynda.com/ajax/player/conviva', video_id,
	176	'Downloading conviva JSON', query=query)
	177
	178	return {
	179	'id': video_id,
	180	'title': conviva['VideoTitle'],
	181	'description': conviva.get('VideoDescription'),
	182	'release_year': int_or_none(conviva.get('ReleaseYear')),
	183	'duration': int_or_none(conviva.get('Duration')),
	184	'creator': conviva.get('Author'),
	185	'formats': formats,
	186	}
c7f8537d	187
ea8ed40b	188	if 'Status' in video:
30cbd4e0	189	raise ExtractorError(
ea8ed40b	190	'lynda returned error: %s' % video['Message'], expected=True)
c7f8537d	191
ea8ed40b	192	if video.get('HasAccess') is False:
6edfc40a	193	self._raise_unavailable(video_id)
c7f8537d	194
ea8ed40b S	195	video_id = compat_str(video.get('ID') or video_id)
	196	duration = int_or_none(video.get('DurationInSeconds'))
	197	title = video['Title']
c7f8537d	198
16ff7ebc S	199	formats = []
16ff7ebc S	200
ea8ed40b	201	fmts = video.get('Formats')
16ff7ebc	202	if fmts:
ea8ed40b S	203	formats.extend([{
	204	'url': f['Url'],
	205	'ext': f.get('Extension'),
	206	'width': int_or_none(f.get('Width')),
	207	'height': int_or_none(f.get('Height')),
	208	'filesize': int_or_none(f.get('FileSize')),
	209	'format_id': compat_str(f.get('Resolution')) if f.get('Resolution') else None,
	210	} for f in fmts if f.get('Url')])
	211
	212	prioritized_streams = video.get('PrioritizedStreams')
16ff7ebc	213	if prioritized_streams:
5a11b793	214	for prioritized_stream_id, prioritized_stream in prioritized_streams.items():
ea8ed40b S	215	formats.extend([{
ea8ed40b S	216	'url': video_url,
ea8aefd1	217	'height': int_or_none(format_id),
ea8ed40b S	218	'format_id': '%s-%s' % (prioritized_stream_id, format_id),
ea8ed40b S	219	} for format_id, video_url in prioritized_stream.items()])
c7f8537d	220
a57e8ce6	221	self._check_formats(formats, video_id)
c7f8537d	222	self._sort_formats(formats)
7ee40b5d	223
ea8ed40b	224	subtitles = self.extract_subtitles(video_id)
7ee40b5d	225
c7f8537d	226	return {
	227	'id': video_id,
	228	'title': title,
	229	'duration': duration,
62bcfa8c	230	'subtitles': subtitles,
c7f8537d	231	'formats': formats
c7f8537d	232	}
7ee40b5d	233
311c3938 JMF	234	def _fix_subtitles(self, subs):
311c3938 JMF	235	srt = ''
7594be85	236	seq_counter = 0
311c3938 JMF	237	for pos in range(0, len(subs) - 1):
	238	seq_current = subs[pos]
	239	m_current = re.match(self._TIMECODE_REGEX, seq_current['Timecode'])
	240	if m_current is None:
	241	continue
	242	seq_next = subs[pos + 1]
	243	m_next = re.match(self._TIMECODE_REGEX, seq_next['Timecode'])
	244	if m_next is None:
62bcfa8c	245	continue
311c3938 JMF	246	appear_time = m_current.group('timecode')
311c3938 JMF	247	disappear_time = m_next.group('timecode')
7594be85 S	248	text = seq_current['Caption'].strip()
	249	if text:
	250	seq_counter += 1
	251	srt += '%s\r\n%s --> %s\r\n%s\r\n\r\n' % (seq_counter, appear_time, disappear_time, text)
311c3938 JMF	252	if srt:
	253	return srt
	254
ea8ed40b	255	def _get_subtitles(self, video_id):
68d9561c	256	url = 'https://www.lynda.com/ajax/player?videoId=%s&type=transcript' % video_id
311c3938	257	subs = self._download_json(url, None, False)
75ba0efb S	258	fixed_subs = self._fix_subtitles(subs)
	259	if fixed_subs:
	260	return {'en': [{'ext': 'srt', 'data': fixed_subs}]}
311c3938 JMF	261	else:
311c3938 JMF	262	return {}
c7f8537d	263
c7f8537d	264
30cbd4e0	265	class LyndaCourseIE(LyndaBaseIE):
a7c26e73 PH	266	IE_NAME = 'lynda:course'
a7c26e73 PH	267	IE_DESC = 'lynda.com online courses'
c7f8537d	268
	269	# Course link equals to welcome/introduction video link of same course
	270	# We will recognize it as course link
b7c74c04 S	271	_VALID_URL = r'https?://(?:www\|m)\.(?:lynda\.com\|educourse\.ga)/(?P<coursepath>(?:[^/]+/){2,3}(?P<courseid>\d+))-2\.html'
	272
	273	_TESTS = [{
	274	'url': 'https://www.lynda.com/Graphic-Design-tutorials/Grundlagen-guten-Gestaltung/393570-2.html',
	275	'only_matching': True,
	276	}, {
	277	'url': 'https://www.lynda.com/de/Graphic-Design-tutorials/Grundlagen-guten-Gestaltung/393570-2.html',
	278	'only_matching': True,
	279	}]
c7f8537d	280
	281	def _real_extract(self, url):
	282	mobj = re.match(self._VALID_URL, url)
	283	course_path = mobj.group('coursepath')
	284	course_id = mobj.group('courseid')
5f6a1245	285
f2980fdd S	286	item_template = 'https://www.lynda.com/%s/%%s-4.html' % course_path
f2980fdd S	287
71bb0161	288	course = self._download_json(
68d9561c	289	'https://www.lynda.com/ajax/player?courseId=%s&type=course' % course_id,
f2980fdd S	290	course_id, 'Downloading course JSON', fatal=False)
	291
	292	if not course:
	293	webpage = self._download_webpage(url, course_id)
	294	entries = [
	295	self.url_result(
	296	item_template % video_id, ie=LyndaIE.ie_key(),
	297	video_id=video_id)
	298	for video_id in re.findall(
	299	r'data-video-id=["\'](\d+)', webpage)]
	300	return self.playlist_result(
	301	entries, course_id,
	302	self._og_search_title(webpage, fatal=False),
	303	self._og_search_description(webpage))
c7f8537d	304
71bb0161	305	if course.get('Status') == 'NotFound':
30cbd4e0 S	306	raise ExtractorError(
30cbd4e0 S	307	'Course %s does not exist' % course_id, expected=True)
c7f8537d	308
c7f8537d	309	unaccessible_videos = 0
00322ad4	310	entries = []
c7f8537d	311
16ff7ebc S	312	# Might want to extract videos right here from video['Formats'] as it seems 'Formats' is not provided
	313	# by single video API anymore
	314
71bb0161 S	315	for chapter in course['Chapters']:
	316	for video in chapter.get('Videos', []):
	317	if video.get('HasAccess') is False:
c7f8537d	318	unaccessible_videos += 1
c7f8537d	319	continue
00322ad4 S	320	video_id = video.get('ID')
	321	if video_id:
	322	entries.append({
	323	'_type': 'url_transparent',
f2980fdd	324	'url': item_template % video_id,
00322ad4 S	325	'ie_key': LyndaIE.ie_key(),
	326	'chapter': chapter.get('Title'),
	327	'chapter_number': int_or_none(chapter.get('ChapterIndex')),
	328	'chapter_id': compat_str(chapter.get('ID')),
	329	})
c7f8537d	330
c7f8537d	331	if unaccessible_videos > 0:
30cbd4e0 S	332	self._downloader.report_warning(
	333	'%s videos are only available for members (or paid members) and will not be downloaded. '
	334	% unaccessible_videos + self._ACCOUNT_CREDENTIALS_HINT)
c7f8537d	335
71bb0161	336	course_title = course.get('Title')
04343588	337	course_description = course.get('Description')
c7f8537d	338
04343588	339	return self.playlist_result(entries, course_id, course_title, course_description)