@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/raywenderlich.py

@@ -1,177 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from .vimeo import VimeoIE
-from ..compat import compat_str
-from ..utils import (
-    ExtractorError,
-    int_or_none,
-    merge_dicts,
-    try_get,
-    unescapeHTML,
-    unified_timestamp,
-    urljoin,
-)
-
-
-class RayWenderlichIE(InfoExtractor):
-    _VALID_URL = r'''(?x)
-                    https?://
-                        (?:
-                            videos\.raywenderlich\.com/courses|
-                            (?:www\.)?raywenderlich\.com
-                        )/
-                        (?P<course_id>[^/]+)/lessons/(?P<id>\d+)
-                    '''
-
-    _TESTS = [{
-        'url': 'https://www.raywenderlich.com/3530-testing-in-ios/lessons/1',
-        'info_dict': {
-            'id': '248377018',
-            'ext': 'mp4',
-            'title': 'Introduction',
-            'description': 'md5:804d031b3efa9fcb49777d512d74f722',
-            'timestamp': 1513906277,
-            'upload_date': '20171222',
-            'duration': 133,
-            'uploader': 'Ray Wenderlich',
-            'uploader_id': 'user3304672',
-        },
-        'params': {
-            'noplaylist': True,
-            'skip_download': True,
-        },
-        'add_ie': [VimeoIE.ie_key()],
-        'expected_warnings': ['HTTP Error 403: Forbidden'],
-    }, {
-        'url': 'https://videos.raywenderlich.com/courses/105-testing-in-ios/lessons/1',
-        'only_matching': True,
-    }]
-
-    @staticmethod
-    def _extract_video_id(data, lesson_id):
-        if not data:
-            return
-        groups = try_get(data, lambda x: x['groups'], list) or []
-        if not groups:
-            return
-        for group in groups:
-            if not isinstance(group, dict):
-                continue
-            contents = try_get(data, lambda x: x['contents'], list) or []
-            for content in contents:
-                if not isinstance(content, dict):
-                    continue
-                ordinal = int_or_none(content.get('ordinal'))
-                if ordinal != lesson_id:
-                    continue
-                video_id = content.get('identifier')
-                if video_id:
-                    return compat_str(video_id)
-
-    def _real_extract(self, url):
-        mobj = self._match_valid_url(url)
-        course_id, lesson_id = mobj.group('course_id', 'id')
-        display_id = '%s/%s' % (course_id, lesson_id)
-
-        webpage = self._download_webpage(url, display_id)
-
-        thumbnail = self._og_search_thumbnail(
-            webpage, default=None) or self._html_search_meta(
-            'twitter:image', webpage, 'thumbnail')
-
-        if '>Subscribe to unlock' in webpage:
-            raise ExtractorError(
-                'This content is only available for subscribers',
-                expected=True)
-
-        info = {
-            'thumbnail': thumbnail,
-        }
-
-        vimeo_id = self._search_regex(
-            r'data-vimeo-id=["\'](\d+)', webpage, 'vimeo id', default=None)
-
-        if not vimeo_id:
-            data = self._parse_json(
-                self._search_regex(
-                    r'data-collection=(["\'])(?P<data>{.+?})\1', webpage,
-                    'data collection', default='{}', group='data'),
-                display_id, transform_source=unescapeHTML, fatal=False)
-            video_id = self._extract_video_id(
-                data, lesson_id) or self._search_regex(
-                r'/videos/(\d+)/', thumbnail, 'video id')
-            headers = {
-                'Referer': url,
-                'X-Requested-With': 'XMLHttpRequest',
-            }
-            csrf_token = self._html_search_meta(
-                'csrf-token', webpage, 'csrf token', default=None)
-            if csrf_token:
-                headers['X-CSRF-Token'] = csrf_token
-            video = self._download_json(
-                'https://videos.raywenderlich.com/api/v1/videos/%s.json'
-                % video_id, display_id, headers=headers)['video']
-            vimeo_id = video['clips'][0]['provider_id']
-            info.update({
-                '_type': 'url_transparent',
-                'title': video.get('name'),
-                'description': video.get('description') or video.get(
-                    'meta_description'),
-                'duration': int_or_none(video.get('duration')),
-                'timestamp': unified_timestamp(video.get('created_at')),
-            })
-
-        return merge_dicts(info, self.url_result(
-            VimeoIE._smuggle_referrer(
-                'https://player.vimeo.com/video/%s' % vimeo_id, url),
-            ie=VimeoIE.ie_key(), video_id=vimeo_id))
-
-
-class RayWenderlichCourseIE(InfoExtractor):
-    _VALID_URL = r'''(?x)
-                    https?://
-                        (?:
-                            videos\.raywenderlich\.com/courses|
-                            (?:www\.)?raywenderlich\.com
-                        )/
-                        (?P<id>[^/]+)
-                    '''
-
-    _TEST = {
-        'url': 'https://www.raywenderlich.com/3530-testing-in-ios',
-        'info_dict': {
-            'title': 'Testing in iOS',
-            'id': '3530-testing-in-ios',
-        },
-        'params': {
-            'noplaylist': False,
-        },
-        'playlist_count': 29,
-    }
-
-    @classmethod
-    def suitable(cls, url):
-        return False if RayWenderlichIE.suitable(url) else super(
-            RayWenderlichCourseIE, cls).suitable(url)
-
-    def _real_extract(self, url):
-        course_id = self._match_id(url)
-
-        webpage = self._download_webpage(url, course_id)
-
-        entries = []
-        lesson_urls = set()
-        for lesson_url in re.findall(
-                r'<a[^>]+\bhref=["\'](/%s/lessons/\d+)' % course_id, webpage):
-            if lesson_url in lesson_urls:
-                continue
-            lesson_urls.add(lesson_url)
-            entries.append(self.url_result(
-                urljoin(url, lesson_url), ie=RayWenderlichIE.ie_key()))
-
-        title = self._og_search_title(
-            webpage, default=None) or self._html_search_meta(
-            'twitter:title', webpage, 'title', default=None)
-
-        return self.playlist_result(entries, course_id, title)

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

@@ -1,142 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import parse_qs, remove_start, traverse_obj, ExtractorError
-
-
-class RbgTumIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:live\.rbg\.tum\.de|tum\.live)/w/(?P<id>[^?#]+)'
-    _TESTS = [{
-        # Combined view
-        'url': 'https://live.rbg.tum.de/w/cpp/22128',
-        'md5': '53a5e7b3e07128e33bbf36687fe1c08f',
-        'info_dict': {
-            'id': 'cpp/22128',
-            'ext': 'mp4',
-            'title': 'Lecture: October 18. 2022',
-            'series': 'Concepts of C++ programming (IN2377)',
-        }
-    }, {
-        # Presentation only
-        'url': 'https://live.rbg.tum.de/w/I2DL/12349/PRES',
-        'md5': '36c584272179f3e56b0db5d880639cba',
-        'info_dict': {
-            'id': 'I2DL/12349/PRES',
-            'ext': 'mp4',
-            'title': 'Lecture 3: Introduction to Neural Networks',
-            'series': 'Introduction to Deep Learning (IN2346)',
-        }
-    }, {
-        # Camera only
-        'url': 'https://live.rbg.tum.de/w/fvv-info/16130/CAM',
-        'md5': 'e04189d92ff2f56aedf5cede65d37aad',
-        'info_dict': {
-            'id': 'fvv-info/16130/CAM',
-            'ext': 'mp4',
-            'title': 'Fachschaftsvollversammlung',
-            'series': 'Fachschaftsvollversammlung Informatik',
-        }
-    }, {
-        'url': 'https://tum.live/w/linalginfo/27102',
-        'only_matching': True,
-    }, ]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        webpage = self._download_webpage(url, video_id)
-
-        m3u8 = self._html_search_regex(r'"(https://[^"]+\.m3u8[^"]*)', webpage, 'm3u8')
-        lecture_title = self._html_search_regex(r'<h1[^>]*>([^<]+)</h1>', webpage, 'title', fatal=False)
-        lecture_series_title = remove_start(self._html_extract_title(webpage), 'TUM-Live | ')
-
-        formats = self._extract_m3u8_formats(m3u8, video_id, 'mp4', entry_protocol='m3u8_native', m3u8_id='hls')
-
-        return {
-            'id': video_id,
-            'title': lecture_title,
-            'series': lecture_series_title,
-            'formats': formats,
-        }
-
-
-class RbgTumCourseIE(InfoExtractor):
-    _VALID_URL = r'https?://(?P<hostname>(?:live\.rbg\.tum\.de|tum\.live))/old/course/(?P<id>(?P<year>\d+)/(?P<term>\w+)/(?P<slug>[^/?#]+))'
-    _TESTS = [{
-        'url': 'https://live.rbg.tum.de/old/course/2022/S/fpv',
-        'info_dict': {
-            'title': 'Funktionale Programmierung und Verifikation (IN0003)',
-            'id': '2022/S/fpv',
-        },
-        'params': {
-            'noplaylist': False,
-        },
-        'playlist_count': 13,
-    }, {
-        'url': 'https://live.rbg.tum.de/old/course/2022/W/set',
-        'info_dict': {
-            'title': 'SET FSMPIC',
-            'id': '2022/W/set',
-        },
-        'params': {
-            'noplaylist': False,
-        },
-        'playlist_count': 6,
-    }, {
-        'url': 'https://tum.live/old/course/2023/S/linalginfo',
-        'only_matching': True,
-    }, ]
-
-    def _real_extract(self, url):
-        course_id, hostname, year, term, slug = self._match_valid_url(url).group('id', 'hostname', 'year', 'term', 'slug')
-        meta = self._download_json(
-            f'https://{hostname}/api/courses/{slug}/', course_id, fatal=False,
-            query={'year': year, 'term': term}) or {}
-        lecture_series_title = meta.get('Name')
-        lectures = [self.url_result(f'https://{hostname}/w/{slug}/{stream_id}', RbgTumIE)
-                    for stream_id in traverse_obj(meta, ('Streams', ..., 'ID'))]
-
-        if not lectures:
-            webpage = self._download_webpage(url, course_id)
-            lecture_series_title = remove_start(self._html_extract_title(webpage), 'TUM-Live | ')
-            lectures = [self.url_result(f'https://{hostname}{lecture_path}', RbgTumIE)
-                        for lecture_path in re.findall(r'href="(/w/[^/"]+/[^/"]+)"', webpage)]
-
-        return self.playlist_result(lectures, course_id, lecture_series_title)
-
-
-class RbgTumNewCourseIE(InfoExtractor):
-    _VALID_URL = r'https?://(?P<hostname>(?:live\.rbg\.tum\.de|tum\.live))/\?'
-    _TESTS = [{
-        'url': 'https://live.rbg.tum.de/?year=2022&term=S&slug=fpv&view=3',
-        'info_dict': {
-            'title': 'Funktionale Programmierung und Verifikation (IN0003)',
-            'id': '2022/S/fpv',
-        },
-        'params': {
-            'noplaylist': False,
-        },
-        'playlist_count': 13,
-    }, {
-        'url': 'https://live.rbg.tum.de/?year=2022&term=W&slug=set&view=3',
-        'info_dict': {
-            'title': 'SET FSMPIC',
-            'id': '2022/W/set',
-        },
-        'params': {
-            'noplaylist': False,
-        },
-        'playlist_count': 6,
-    }, {
-        'url': 'https://tum.live/?year=2023&term=S&slug=linalginfo&view=3',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        query = parse_qs(url)
-        errors = [key for key in ('year', 'term', 'slug') if not query.get(key)]
-        if errors:
-            raise ExtractorError(f'Input URL is missing query parameters: {", ".join(errors)}')
-        year, term, slug = query['year'][0], query['term'][0], query['slug'][0]
-        hostname = self._match_valid_url(url).group('hostname')
-
-        return self.url_result(f'https://{hostname}/old/course/{year}/{term}/{slug}', RbgTumCourseIE)