@tushar-br/desktop 1.0.282 → 1.0.283

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/extractor/pluralsight.py

@@ -0,0 +1,491 @@
+import collections
+import json
+import os
+import random
+import re
+
+from .common import InfoExtractor
+from ..compat import (
+    compat_str,
+    compat_urlparse,
+)
+from ..utils import (
+    dict_get,
+    ExtractorError,
+    float_or_none,
+    int_or_none,
+    parse_duration,
+    parse_qs,
+    qualities,
+    srt_subtitles_timecode,
+    try_get,
+    update_url_query,
+    urlencode_postdata,
+)
+
+
+class PluralsightBaseIE(InfoExtractor):
+    _API_BASE = 'https://app.pluralsight.com'
+
+    _GRAPHQL_EP = '%s/player/api/graphql' % _API_BASE
+    _GRAPHQL_HEADERS = {
+        'Content-Type': 'application/json;charset=UTF-8',
+    }
+    _GRAPHQL_COURSE_TMPL = '''
+query BootstrapPlayer {
+  rpc {
+    bootstrapPlayer {
+      profile {
+        firstName
+        lastName
+        email
+        username
+        userHandle
+        authed
+        isAuthed
+        plan
+      }
+      course(courseId: "%s") {
+        name
+        title
+        courseHasCaptions
+        translationLanguages {
+          code
+          name
+        }
+        supportsWideScreenVideoFormats
+        timestamp
+        modules {
+          name
+          title
+          duration
+          formattedDuration
+          author
+          authorized
+          clips {
+            authorized
+            clipId
+            duration
+            formattedDuration
+            id
+            index
+            moduleIndex
+            moduleTitle
+            name
+            title
+            watched
+          }
+        }
+      }
+    }
+  }
+}'''
+
+    def _download_course(self, course_id, url, display_id):
+        try:
+            return self._download_course_rpc(course_id, url, display_id)
+        except ExtractorError:
+            # Old API fallback
+            return self._download_json(
+                'https://app.pluralsight.com/player/user/api/v1/player/payload',
+                display_id, data=urlencode_postdata({'courseId': course_id}),
+                headers={'Referer': url})
+
+    def _download_course_rpc(self, course_id, url, display_id):
+        response = self._download_json(
+            self._GRAPHQL_EP, display_id, data=json.dumps({
+                'query': self._GRAPHQL_COURSE_TMPL % course_id,
+                'variables': {}
+            }).encode('utf-8'), headers=self._GRAPHQL_HEADERS)
+
+        course = try_get(
+            response, lambda x: x['data']['rpc']['bootstrapPlayer']['course'],
+            dict)
+        if course:
+            return course
+
+        raise ExtractorError(
+            '%s said: %s' % (self.IE_NAME, response['error']['message']),
+            expected=True)
+
+
+class PluralsightIE(PluralsightBaseIE):
+    IE_NAME = 'pluralsight'
+    _VALID_URL = r'https?://(?:(?:www|app)\.)?pluralsight\.com/(?:training/)?player\?'
+    _LOGIN_URL = 'https://app.pluralsight.com/id/'
+
+    _NETRC_MACHINE = 'pluralsight'
+
+    _TESTS = [{
+        'url': 'http://www.pluralsight.com/training/player?author=mike-mckeown&name=hosting-sql-server-windows-azure-iaas-m7-mgmt&mode=live&clip=3&course=hosting-sql-server-windows-azure-iaas',
+        'md5': '4d458cf5cf4c593788672419a8dd4cf8',
+        'info_dict': {
+            'id': 'hosting-sql-server-windows-azure-iaas-m7-mgmt-04',
+            'ext': 'mp4',
+            'title': 'Demo Monitoring',
+            'duration': 338,
+        },
+        'skip': 'Requires pluralsight account credentials',
+    }, {
+        'url': 'https://app.pluralsight.com/training/player?course=angularjs-get-started&author=scott-allen&name=angularjs-get-started-m1-introduction&clip=0&mode=live',
+        'only_matching': True,
+    }, {
+        # available without pluralsight account
+        'url': 'http://app.pluralsight.com/training/player?author=scott-allen&name=angularjs-get-started-m1-introduction&mode=live&clip=0&course=angularjs-get-started',
+        'only_matching': True,
+    }, {
+        'url': 'https://app.pluralsight.com/player?course=ccna-intro-networking&author=ross-bagurdes&name=ccna-intro-networking-m06&clip=0',
+        'only_matching': True,
+    }]
+
+    GRAPHQL_VIEWCLIP_TMPL = '''
+query viewClip {
+  viewClip(input: {
+    author: "%(author)s",
+    clipIndex: %(clipIndex)d,
+    courseName: "%(courseName)s",
+    includeCaptions: %(includeCaptions)s,
+    locale: "%(locale)s",
+    mediaType: "%(mediaType)s",
+    moduleName: "%(moduleName)s",
+    quality: "%(quality)s"
+  }) {
+    urls {
+      url
+      cdn
+      rank
+      source
+    },
+    status
+  }
+}'''
+
+    def _perform_login(self, username, password):
+        login_page = self._download_webpage(
+            self._LOGIN_URL, None, 'Downloading login page')
+
+        login_form = self._hidden_inputs(login_page)
+
+        login_form.update({
+            'Username': username,
+            'Password': password,
+        })
+
+        post_url = self._search_regex(
+            r'<form[^>]+action=(["\'])(?P<url>.+?)\1', login_page,
+            'post url', default=self._LOGIN_URL, group='url')
+
+        if not post_url.startswith('http'):
+            post_url = compat_urlparse.urljoin(self._LOGIN_URL, post_url)
+
+        response = self._download_webpage(
+            post_url, None, 'Logging in',
+            data=urlencode_postdata(login_form),
+            headers={'Content-Type': 'application/x-www-form-urlencoded'})
+
+        error = self._search_regex(
+            r'<span[^>]+class="field-validation-error"[^>]*>([^<]+)</span>',
+            response, 'error message', default=None)
+        if error:
+            raise ExtractorError('Unable to login: %s' % error, expected=True)
+
+        if all(not re.search(p, response) for p in (
+                r'__INITIAL_STATE__', r'["\']currentUser["\']',
+                # new layout?
+                r'>\s*Sign out\s*<')):
+            BLOCKED = 'Your account has been blocked due to suspicious activity'
+            if BLOCKED in response:
+                raise ExtractorError(
+                    'Unable to login: %s' % BLOCKED, expected=True)
+            MUST_AGREE = 'To continue using Pluralsight, you must agree to'
+            if any(p in response for p in (MUST_AGREE, '>Disagree<', '>Agree<')):
+                raise ExtractorError(
+                    'Unable to login: %s some documents. Go to pluralsight.com, '
+                    'log in and agree with what Pluralsight requires.'
+                    % MUST_AGREE, expected=True)
+
+            raise ExtractorError('Unable to log in')
+
+    def _get_subtitles(self, author, clip_idx, clip_id, lang, name, duration, video_id):
+        captions = None
+        if clip_id:
+            captions = self._download_json(
+                '%s/transcript/api/v1/caption/json/%s/%s'
+                % (self._API_BASE, clip_id, lang), video_id,
+                'Downloading captions JSON', 'Unable to download captions JSON',
+                fatal=False)
+        if not captions:
+            captions_post = {
+                'a': author,
+                'cn': int(clip_idx),
+                'lc': lang,
+                'm': name,
+            }
+            captions = self._download_json(
+                '%s/player/retrieve-captions' % self._API_BASE, video_id,
+                'Downloading captions JSON', 'Unable to download captions JSON',
+                fatal=False, data=json.dumps(captions_post).encode('utf-8'),
+                headers={'Content-Type': 'application/json;charset=utf-8'})
+        if captions:
+            return {
+                lang: [{
+                    'ext': 'json',
+                    'data': json.dumps(captions),
+                }, {
+                    'ext': 'srt',
+                    'data': self._convert_subtitles(duration, captions),
+                }]
+            }
+
+    @staticmethod
+    def _convert_subtitles(duration, subs):
+        srt = ''
+        TIME_OFFSET_KEYS = ('displayTimeOffset', 'DisplayTimeOffset')
+        TEXT_KEYS = ('text', 'Text')
+        for num, current in enumerate(subs):
+            current = subs[num]
+            start, text = (
+                float_or_none(dict_get(current, TIME_OFFSET_KEYS, skip_false_values=False)),
+                dict_get(current, TEXT_KEYS))
+            if start is None or text is None:
+                continue
+            end = duration if num == len(subs) - 1 else float_or_none(
+                dict_get(subs[num + 1], TIME_OFFSET_KEYS, skip_false_values=False))
+            if end is None:
+                continue
+            srt += os.linesep.join(
+                (
+                    '%d' % num,
+                    '%s --> %s' % (
+                        srt_subtitles_timecode(start),
+                        srt_subtitles_timecode(end)),
+                    text,
+                    os.linesep,
+                ))
+        return srt
+
+    def _real_extract(self, url):
+        qs = parse_qs(url)
+
+        author = qs.get('author', [None])[0]
+        name = qs.get('name', [None])[0]
+        clip_idx = qs.get('clip', [None])[0]
+        course_name = qs.get('course', [None])[0]
+
+        if any(not f for f in (author, name, clip_idx, course_name,)):
+            raise ExtractorError('Invalid URL', expected=True)
+
+        display_id = '%s-%s' % (name, clip_idx)
+
+        course = self._download_course(course_name, url, display_id)
+
+        collection = course['modules']
+
+        clip = None
+
+        for module_ in collection:
+            if name in (module_.get('moduleName'), module_.get('name')):
+                for clip_ in module_.get('clips', []):
+                    clip_index = clip_.get('clipIndex')
+                    if clip_index is None:
+                        clip_index = clip_.get('index')
+                    if clip_index is None:
+                        continue
+                    if compat_str(clip_index) == clip_idx:
+                        clip = clip_
+                        break
+
+        if not clip:
+            raise ExtractorError('Unable to resolve clip')
+
+        title = clip['title']
+        clip_id = clip.get('clipName') or clip.get('name') or clip['clipId']
+
+        QUALITIES = {
+            'low': {'width': 640, 'height': 480},
+            'medium': {'width': 848, 'height': 640},
+            'high': {'width': 1024, 'height': 768},
+            'high-widescreen': {'width': 1280, 'height': 720},
+        }
+
+        QUALITIES_PREFERENCE = ('low', 'medium', 'high', 'high-widescreen',)
+        quality_key = qualities(QUALITIES_PREFERENCE)
+
+        AllowedQuality = collections.namedtuple('AllowedQuality', ['ext', 'qualities'])
+
+        ALLOWED_QUALITIES = (
+            AllowedQuality('webm', ['high', ]),
+            AllowedQuality('mp4', ['low', 'medium', 'high', ]),
+        )
+
+        # Some courses also offer widescreen resolution for high quality (see
+        # https://github.com/ytdl-org/youtube-dl/issues/7766)
+        widescreen = course.get('supportsWideScreenVideoFormats') is True
+        best_quality = 'high-widescreen' if widescreen else 'high'
+        if widescreen:
+            for allowed_quality in ALLOWED_QUALITIES:
+                allowed_quality.qualities.append(best_quality)
+
+        # In order to minimize the number of calls to ViewClip API and reduce
+        # the probability of being throttled or banned by Pluralsight we will request
+        # only single format until formats listing was explicitly requested.
+        if self.get_param('listformats', False):
+            allowed_qualities = ALLOWED_QUALITIES
+        else:
+            def guess_allowed_qualities():
+                req_format = self.get_param('format') or 'best'
+                req_format_split = req_format.split('-', 1)
+                if len(req_format_split) > 1:
+                    req_ext, req_quality = req_format_split
+                    req_quality = '-'.join(req_quality.split('-')[:2])
+                    for allowed_quality in ALLOWED_QUALITIES:
+                        if req_ext == allowed_quality.ext and req_quality in allowed_quality.qualities:
+                            return (AllowedQuality(req_ext, (req_quality, )), )
+                req_ext = 'webm' if self.get_param('prefer_free_formats') else 'mp4'
+                return (AllowedQuality(req_ext, (best_quality, )), )
+            allowed_qualities = guess_allowed_qualities()
+
+        formats = []
+        for ext, qualities_ in allowed_qualities:
+            for quality in qualities_:
+                f = QUALITIES[quality].copy()
+                clip_post = {
+                    'author': author,
+                    'includeCaptions': 'false',
+                    'clipIndex': int(clip_idx),
+                    'courseName': course_name,
+                    'locale': 'en',
+                    'moduleName': name,
+                    'mediaType': ext,
+                    'quality': '%dx%d' % (f['width'], f['height']),
+                }
+                format_id = '%s-%s' % (ext, quality)
+
+                try:
+                    viewclip = self._download_json(
+                        self._GRAPHQL_EP, display_id,
+                        'Downloading %s viewclip graphql' % format_id,
+                        data=json.dumps({
+                            'query': self.GRAPHQL_VIEWCLIP_TMPL % clip_post,
+                            'variables': {}
+                        }).encode('utf-8'),
+                        headers=self._GRAPHQL_HEADERS)['data']['viewClip']
+                except ExtractorError:
+                    # Still works but most likely will go soon
+                    viewclip = self._download_json(
+                        '%s/video/clips/viewclip' % self._API_BASE, display_id,
+                        'Downloading %s viewclip JSON' % format_id, fatal=False,
+                        data=json.dumps(clip_post).encode('utf-8'),
+                        headers={'Content-Type': 'application/json;charset=utf-8'})
+
+                # Pluralsight tracks multiple sequential calls to ViewClip API and start
+                # to return 429 HTTP errors after some time (see
+                # https://github.com/ytdl-org/youtube-dl/pull/6989). Moreover it may even lead
+                # to account ban (see https://github.com/ytdl-org/youtube-dl/issues/6842).
+                # To somewhat reduce the probability of these consequences
+                # we will sleep random amount of time before each call to ViewClip.
+                self._sleep(
+                    random.randint(5, 10), display_id,
+                    '%(video_id)s: Waiting for %(timeout)s seconds to avoid throttling')
+
+                if not viewclip:
+                    continue
+
+                clip_urls = viewclip.get('urls')
+                if not isinstance(clip_urls, list):
+                    continue
+
+                for clip_url_data in clip_urls:
+                    clip_url = clip_url_data.get('url')
+                    if not clip_url:
+                        continue
+                    cdn = clip_url_data.get('cdn')
+                    clip_f = f.copy()
+                    clip_f.update({
+                        'url': clip_url,
+                        'ext': ext,
+                        'format_id': '%s-%s' % (format_id, cdn) if cdn else format_id,
+                        'quality': quality_key(quality),
+                        'source_preference': int_or_none(clip_url_data.get('rank')),
+                    })
+                    formats.append(clip_f)
+
+        duration = int_or_none(
+            clip.get('duration')) or parse_duration(clip.get('formattedDuration'))
+
+        # TODO: other languages?
+        subtitles = self.extract_subtitles(
+            author, clip_idx, clip.get('clipId'), 'en', name, duration, display_id)
+
+        return {
+            'id': clip_id,
+            'title': title,
+            'duration': duration,
+            'creator': author,
+            'formats': formats,
+            'subtitles': subtitles,
+        }
+
+
+class PluralsightCourseIE(PluralsightBaseIE):
+    IE_NAME = 'pluralsight:course'
+    _VALID_URL = r'https?://(?:(?:www|app)\.)?pluralsight\.com/(?:library/)?courses/(?P<id>[^/]+)'
+    _TESTS = [{
+        # Free course from Pluralsight Starter Subscription for Microsoft TechNet
+        # https://offers.pluralsight.com/technet?loc=zTS3z&prod=zOTprodz&tech=zOttechz&prog=zOTprogz&type=zSOz&media=zOTmediaz&country=zUSz
+        'url': 'http://www.pluralsight.com/courses/hosting-sql-server-windows-azure-iaas',
+        'info_dict': {
+            'id': 'hosting-sql-server-windows-azure-iaas',
+            'title': 'Hosting SQL Server in Microsoft Azure IaaS Fundamentals',
+            'description': 'md5:61b37e60f21c4b2f91dc621a977d0986',
+        },
+        'playlist_count': 31,
+    }, {
+        # available without pluralsight account
+        'url': 'https://www.pluralsight.com/courses/angularjs-get-started',
+        'only_matching': True,
+    }, {
+        'url': 'https://app.pluralsight.com/library/courses/understanding-microsoft-azure-amazon-aws/table-of-contents',
+        'only_matching': True,
+    }]
+
+    def _real_extract(self, url):
+        course_id = self._match_id(url)
+
+        # TODO: PSM cookie
+
+        course = self._download_course(course_id, url, course_id)
+
+        title = course['title']
+        course_name = course['name']
+        course_data = course['modules']
+        description = course.get('description') or course.get('shortDescription')
+
+        entries = []
+        for num, module in enumerate(course_data, 1):
+            author = module.get('author')
+            module_name = module.get('name')
+            if not author or not module_name:
+                continue
+            for clip in module.get('clips', []):
+                clip_index = int_or_none(clip.get('index'))
+                if clip_index is None:
+                    continue
+                clip_url = update_url_query(
+                    '%s/player' % self._API_BASE, query={
+                        'mode': 'live',
+                        'course': course_name,
+                        'author': author,
+                        'name': module_name,
+                        'clip': clip_index,
+                    })
+                entries.append({
+                    '_type': 'url_transparent',
+                    'url': clip_url,
+                    'ie_key': PluralsightIE.ie_key(),
+                    'chapter': module.get('title'),
+                    'chapter_number': num,
+                    'chapter_id': module.get('moduleRef'),
+                })
+
+        return self.playlist_result(entries, course_id, title, description)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/extractor/plutotv.py

@@ -0,0 +1,195 @@
+import re
+import uuid
+
+from .common import InfoExtractor
+from ..compat import (
+    compat_str,
+    compat_urlparse,
+)
+from ..utils import (
+    ExtractorError,
+    float_or_none,
+    int_or_none,
+    try_get,
+    url_or_none,
+)
+
+
+class PlutoTVIE(InfoExtractor):
+    _WORKING = False
+    _VALID_URL = r'''(?x)
+        https?://(?:www\.)?pluto\.tv(?:/[^/]+)?/on-demand
+        /(?P<video_type>movies|series)
+        /(?P<series_or_movie_slug>[^/]+)
+        (?:
+            (?:/seasons?/(?P<season_no>\d+))?
+            (?:/episode/(?P<episode_slug>[^/]+))?
+        )?
+        /?(?:$|[#?])'''
+
+    _INFO_URL = 'https://service-vod.clusters.pluto.tv/v3/vod/slugs/'
+    _INFO_QUERY_PARAMS = {
+        'appName': 'web',
+        'appVersion': 'na',
+        'clientID': compat_str(uuid.uuid1()),
+        'clientModelNumber': 'na',
+        'serverSideAds': 'false',
+        'deviceMake': 'unknown',
+        'deviceModel': 'web',
+        'deviceType': 'web',
+        'deviceVersion': 'unknown',
+        'sid': compat_str(uuid.uuid1()),
+    }
+    _TESTS = [
+        {
+            'url': 'https://pluto.tv/on-demand/series/i-love-money/season/2/episode/its-in-the-cards-2009-2-3',
+            'md5': 'ebcdd8ed89aaace9df37924f722fd9bd',
+            'info_dict': {
+                'id': '5de6c598e9379ae4912df0a8',
+                'ext': 'mp4',
+                'title': 'It\'s In The Cards',
+                'episode': 'It\'s In The Cards',
+                'description': 'The teams face off against each other in a 3-on-2 soccer showdown.  Strategy comes into play, though, as each team gets to select their opposing teams’ two defenders.',
+                'series': 'I Love Money',
+                'season_number': 2,
+                'episode_number': 3,
+                'duration': 3600,
+            }
+        }, {
+            'url': 'https://pluto.tv/on-demand/series/i-love-money/season/1/',
+            'playlist_count': 11,
+            'info_dict': {
+                'id': '5de6c582e9379ae4912dedbd',
+                'title': 'I Love Money - Season 1',
+            }
+        }, {
+            'url': 'https://pluto.tv/on-demand/series/i-love-money/',
+            'playlist_count': 26,
+            'info_dict': {
+                'id': '5de6c582e9379ae4912dedbd',
+                'title': 'I Love Money',
+            }
+        }, {
+            'url': 'https://pluto.tv/on-demand/movies/arrival-2015-1-1',
+            'md5': '3cead001d317a018bf856a896dee1762',
+            'info_dict': {
+                'id': '5e83ac701fa6a9001bb9df24',
+                'ext': 'mp4',
+                'title': 'Arrival',
+                'description': 'When mysterious spacecraft touch down across the globe, an elite team - led by expert translator Louise Banks (Academy Award® nominee Amy Adams) – races against time to decipher their intent.',
+                'duration': 9000,
+            }
+        }, {
+            'url': 'https://pluto.tv/en/on-demand/series/manhunters-fugitive-task-force/seasons/1/episode/third-times-the-charm-1-1',
+            'only_matching': True,
+        }, {
+            'url': 'https://pluto.tv/it/on-demand/series/csi-vegas/episode/legacy-2021-1-1',
+            'only_matching': True,
+        },
+        {
+            'url': 'https://pluto.tv/en/on-demand/movies/attack-of-the-killer-tomatoes-1977-1-1-ptv1',
+            'md5': '7db56369c0da626a32d505ec6eb3f89f',
+            'info_dict': {
+                'id': '5b190c7bb0875c36c90c29c4',
+                'ext': 'mp4',
+                'title': 'Attack of the Killer Tomatoes',
+                'description': 'A group of scientists band together to save the world from mutated tomatoes that KILL! (1978)',
+                'duration': 5700,
+            }
+        }
+    ]
+
+    def _to_ad_free_formats(self, video_id, formats, subtitles):
+        ad_free_formats, ad_free_subtitles, m3u8_urls = [], {}, set()
+        for fmt in formats:
+            res = self._download_webpage(
+                fmt.get('url'), video_id, note='Downloading m3u8 playlist',
+                fatal=False)
+            if not res:
+                continue
+            first_segment_url = re.search(
+                r'^(https?://.*/)0\-(end|[0-9]+)/[^/]+\.ts$', res,
+                re.MULTILINE)
+            if first_segment_url:
+                m3u8_urls.add(
+                    compat_urlparse.urljoin(first_segment_url.group(1), '0-end/master.m3u8'))
+                continue
+            first_segment_url = re.search(
+                r'^(https?://.*/).+\-0+[0-1]0\.ts$', res,
+                re.MULTILINE)
+            if first_segment_url:
+                m3u8_urls.add(
+                    compat_urlparse.urljoin(first_segment_url.group(1), 'master.m3u8'))
+                continue
+
+        for m3u8_url in m3u8_urls:
+            fmts, subs = self._extract_m3u8_formats_and_subtitles(
+                m3u8_url, video_id, 'mp4', 'm3u8_native', m3u8_id='hls', fatal=False)
+            ad_free_formats.extend(fmts)
+            ad_free_subtitles = self._merge_subtitles(ad_free_subtitles, subs)
+        if ad_free_formats:
+            formats, subtitles = ad_free_formats, ad_free_subtitles
+        else:
+            self.report_warning('Unable to find ad-free formats')
+        return formats, subtitles
+
+    def _get_video_info(self, video_json, slug, series_name=None):
+        video_id = video_json.get('_id', slug)
+        formats, subtitles = [], {}
+        for video_url in try_get(video_json, lambda x: x['stitched']['urls'], list) or []:
+            if video_url.get('type') != 'hls':
+                continue
+            url = url_or_none(video_url.get('url'))
+
+            fmts, subs = self._extract_m3u8_formats_and_subtitles(
+                url, video_id, 'mp4', 'm3u8_native', m3u8_id='hls', fatal=False)
+            formats.extend(fmts)
+            subtitles = self._merge_subtitles(subtitles, subs)
+
+        formats, subtitles = self._to_ad_free_formats(video_id, formats, subtitles)
+
+        info = {
+            'id': video_id,
+            'formats': formats,
+            'subtitles': subtitles,
+            'title': video_json.get('name'),
+            'description': video_json.get('description'),
+            'duration': float_or_none(video_json.get('duration'), scale=1000),
+        }
+        if series_name:
+            info.update({
+                'series': series_name,
+                'episode': video_json.get('name'),
+                'season_number': int_or_none(video_json.get('season')),
+                'episode_number': int_or_none(video_json.get('number')),
+            })
+        return info
+
+    def _real_extract(self, url):
+        mobj = self._match_valid_url(url).groupdict()
+        info_slug = mobj['series_or_movie_slug']
+        video_json = self._download_json(self._INFO_URL + info_slug, info_slug, query=self._INFO_QUERY_PARAMS)
+
+        if mobj['video_type'] == 'series':
+            series_name = video_json.get('name', info_slug)
+            season_number, episode_slug = mobj.get('season_number'), mobj.get('episode_slug')
+
+            videos = []
+            for season in video_json['seasons']:
+                if season_number is not None and season_number != int_or_none(season.get('number')):
+                    continue
+                for episode in season['episodes']:
+                    if episode_slug is not None and episode_slug != episode.get('slug'):
+                        continue
+                    videos.append(self._get_video_info(episode, episode_slug, series_name))
+            if not videos:
+                raise ExtractorError('Failed to find any videos to extract')
+            if episode_slug is not None and len(videos) == 1:
+                return videos[0]
+            playlist_title = series_name
+            if season_number is not None:
+                playlist_title += ' - Season %d' % season_number
+            return self.playlist_result(videos,
+                                        playlist_id=video_json.get('_id', info_slug),
+                                        playlist_title=playlist_title)
+        return self._get_video_info(video_json, info_slug)