@tushar-br/desktop 1.0.283 → 1.0.284

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

@@ -1,491 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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)