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

@@ -1,134 +0,0 @@
-import hashlib
-import random
-import re
-
-from ..compat import compat_urlparse, compat_b64decode
-
-from ..utils import (
-    ExtractorError,
-    int_or_none,
-    str_or_none,
-    try_get,
-    unescapeHTML,
-    update_url_query,
-)
-
-from .common import InfoExtractor
-
-
-class HuyaLiveIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.|m\.)?huya\.com/(?P<id>[^/#?&]+)(?:\D|$)'
-    IE_NAME = 'huya:live'
-    IE_DESC = 'huya.com'
-    TESTS = [{
-        'url': 'https://www.huya.com/572329',
-        'info_dict': {
-            'id': '572329',
-            'title': str,
-            'description': str,
-            'is_live': True,
-            'view_count': int,
-        },
-        'params': {
-            'skip_download': True,
-        },
-    }, {
-        'url': 'https://www.huya.com/xiaoyugame',
-        'only_matching': True
-    }]
-
-    _RESOLUTION = {
-        '蓝光': {
-            'width': 1920,
-            'height': 1080,
-        },
-        '超清': {
-            'width': 1280,
-            'height': 720,
-        },
-        '流畅': {
-            'width': 800,
-            'height': 480
-        }
-    }
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        webpage = self._download_webpage(url, video_id=video_id)
-        stream_data = self._search_json(r'stream:\s', webpage, 'stream', video_id=video_id, default=None)
-        room_info = try_get(stream_data, lambda x: x['data'][0]['gameLiveInfo'])
-        if not room_info:
-            raise ExtractorError('Can not extract the room info', expected=True)
-        title = room_info.get('roomName') or room_info.get('introduction') or self._html_extract_title(webpage)
-        screen_type = room_info.get('screenType')
-        live_source_type = room_info.get('liveSourceType')
-        stream_info_list = stream_data['data'][0]['gameStreamInfoList']
-        if not stream_info_list:
-            raise ExtractorError('Video is offline', expected=True)
-        formats = []
-        for stream_info in stream_info_list:
-            stream_url = stream_info.get('sFlvUrl')
-            if not stream_url:
-                continue
-            stream_name = stream_info.get('sStreamName')
-            re_secret = not screen_type and live_source_type in (0, 8, 13)
-            params = dict(compat_urlparse.parse_qsl(unescapeHTML(stream_info['sFlvAntiCode'])))
-            fm, ss = '', ''
-            if re_secret:
-                fm, ss = self.encrypt(params, stream_info, stream_name)
-            for si in stream_data.get('vMultiStreamInfo'):
-                display_name, bitrate = re.fullmatch(
-                    r'(.+?)(?:(\d+)M)?', si.get('sDisplayName')).groups()
-                rate = si.get('iBitRate')
-                if rate:
-                    params['ratio'] = rate
-                else:
-                    params.pop('ratio', None)
-                    if bitrate:
-                        rate = int(bitrate) * 1000
-                if re_secret:
-                    params['wsSecret'] = hashlib.md5(
-                        '_'.join([fm, params['u'], stream_name, ss, params['wsTime']]))
-                formats.append({
-                    'ext': stream_info.get('sFlvUrlSuffix'),
-                    'format_id': str_or_none(stream_info.get('iLineIndex')),
-                    'tbr': rate,
-                    'url': update_url_query(f'{stream_url}/{stream_name}.{stream_info.get("sFlvUrlSuffix")}',
-                                            query=params),
-                    **self._RESOLUTION.get(display_name, {}),
-                })
-
-        return {
-            'id': video_id,
-            'title': title,
-            'formats': formats,
-            'view_count': room_info.get('totalCount'),
-            'thumbnail': room_info.get('screenshot'),
-            'description': room_info.get('contentIntro'),
-            'http_headers': {
-                'Origin': 'https://www.huya.com',
-                'Referer': 'https://www.huya.com/',
-            },
-        }
-
-    def encrypt(self, params, stream_info, stream_name):
-        ct = int_or_none(params.get('wsTime'), 16) + random.random()
-        presenter_uid = stream_info['lPresenterUid']
-        if not stream_name.startswith(str(presenter_uid)):
-            uid = presenter_uid
-        else:
-            uid = int_or_none(ct % 1e7 * 1e6 % 0xffffffff)
-        u1 = uid & 0xffffffff00000000
-        u2 = uid & 0xffffffff
-        u3 = uid & 0xffffff
-        u = u1 | u2 >> 24 | u3 << 8
-        params.update({
-            'u': str_or_none(u),
-            'seqid': str_or_none(int_or_none(ct * 1000) + uid),
-            'ver': '1',
-            'uuid': int_or_none(ct % 1e7 * 1e6 % 0xffffffff),
-            't': '100',
-        })
-        fm = compat_b64decode(params['fm']).decode().split('_', 1)[0]
-        ss = hashlib.md5('|'.join([params['seqid'], params['ctype'], params['t']]))
-        return fm, ss

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

@@ -1,47 +0,0 @@
-from .common import InfoExtractor
-from ..utils import int_or_none
-
-
-class HypemIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?hypem\.com/track/(?P<id>[0-9a-z]{5})'
-    _TEST = {
-        'url': 'http://hypem.com/track/1v6ga/BODYWORK+-+TAME',
-        'md5': 'b9cc91b5af8995e9f0c1cee04c575828',
-        'info_dict': {
-            'id': '1v6ga',
-            'ext': 'mp3',
-            'title': 'Tame',
-            'uploader': 'BODYWORK',
-            'timestamp': 1371810457,
-            'upload_date': '20130621',
-        }
-    }
-
-    def _real_extract(self, url):
-        track_id = self._match_id(url)
-
-        response = self._download_webpage(url, track_id)
-
-        track = self._parse_json(self._html_search_regex(
-            r'(?s)<script\s+type="application/json"\s+id="displayList-data">(.+?)</script>',
-            response, 'tracks'), track_id)['tracks'][0]
-
-        track_id = track['id']
-        title = track['song']
-
-        final_url = self._download_json(
-            'http://hypem.com/serve/source/%s/%s' % (track_id, track['key']),
-            track_id, 'Downloading metadata', headers={
-                'Content-Type': 'application/json'
-            })['url']
-
-        return {
-            'id': track_id,
-            'url': final_url,
-            'ext': 'mp3',
-            'title': title,
-            'uploader': track.get('artist'),
-            'duration': int_or_none(track.get('time')),
-            'timestamp': int_or_none(track.get('ts')),
-            'track': title,
-        }

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

@@ -1,32 +0,0 @@
-from .common import InfoExtractor
-from ..utils import js_to_json, traverse_obj
-
-
-class MonsterSirenHypergryphMusicIE(InfoExtractor):
-    _VALID_URL = r'https?://monster-siren\.hypergryph\.com/music/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://monster-siren.hypergryph.com/music/514562',
-        'info_dict': {
-            'id': '514562',
-            'ext': 'wav',
-            'artists': ['塞壬唱片-MSR'],
-            'album': 'Flame Shadow',
-            'title': 'Flame Shadow',
-        }
-    }]
-
-    def _real_extract(self, url):
-        audio_id = self._match_id(url)
-        webpage = self._download_webpage(url, audio_id)
-        json_data = self._search_json(
-            r'window\.g_initialProps\s*=', webpage, 'data', audio_id, transform_source=js_to_json)
-
-        return {
-            'id': audio_id,
-            'title': traverse_obj(json_data, ('player', 'songDetail', 'name')),
-            'url': traverse_obj(json_data, ('player', 'songDetail', 'sourceUrl')),
-            'ext': 'wav',
-            'vcodec': 'none',
-            'artists': traverse_obj(json_data, ('player', 'songDetail', 'artists', ...)),
-            'album': traverse_obj(json_data, ('musicPlay', 'albumDetail', 'name'))
-        }

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

@@ -1,58 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import traverse_obj
-
-
-class HytaleIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?hytale\.com/news/\d+/\d+/(?P<id>[a-z0-9-]+)'
-    _TESTS = [{
-        'url': 'https://hytale.com/news/2021/07/summer-2021-development-update',
-        'info_dict': {
-            'id': 'summer-2021-development-update',
-            'title': 'Summer 2021 Development Update',
-        },
-        'playlist_count': 4,
-        'playlist': [{
-            'md5': '0854ebe347d233ee19b86ab7b2ead610',
-            'info_dict': {
-                'id': 'ed51a2609d21bad6e14145c37c334999',
-                'ext': 'mp4',
-                'title': 'Avatar Personalization',
-                'thumbnail': r're:https://videodelivery\.net/\w+/thumbnails/thumbnail\.jpg',
-            }
-        }]
-    }, {
-        'url': 'https://www.hytale.com/news/2019/11/hytale-graphics-update',
-        'info_dict': {
-            'id': 'hytale-graphics-update',
-            'title': 'Hytale graphics update',
-        },
-        'playlist_count': 2,
-    }]
-
-    def _real_initialize(self):
-        media_webpage = self._download_webpage(
-            'https://hytale.com/media', None, note='Downloading list of media', fatal=False) or ''
-
-        clips_json = traverse_obj(
-            self._search_json(
-                r'window\.__INITIAL_COMPONENTS_STATE__\s*=\s*\[',
-                media_webpage, 'clips json', None),
-            ('media', 'clips')) or []
-
-        self._titles = {clip.get('src'): clip.get('caption') for clip in clips_json}
-
-    def _real_extract(self, url):
-        playlist_id = self._match_id(url)
-        webpage = self._download_webpage(url, playlist_id)
-        entries = [
-            self.url_result(
-                f'https://cloudflarestream.com/{video_hash}/manifest/video.mpd?parentOrigin=https%3A%2F%2Fhytale.com',
-                title=self._titles.get(video_hash), url_transparent=True)
-            for video_hash in re.findall(
-                r'<stream\s+class\s*=\s*"ql-video\s+cf-stream"\s+src\s*=\s*"([a-f0-9]{32})"',
-                webpage)
-        ]
-
-        return self.playlist_result(entries, playlist_id, self._og_search_title(webpage))

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

@@ -1,179 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import (
-    clean_html,
-    determine_ext,
-    get_element_by_class,
-    int_or_none,
-    merge_dicts,
-    parse_bitrate,
-    parse_resolution,
-    remove_end,
-    str_or_none,
-    url_or_none,
-    urlencode_postdata,
-)
-
-
-class IcareusIE(InfoExtractor):
-    _DOMAINS = '|'.join(map(re.escape, (
-        'asahitv.fi',
-        'helsinkikanava.fi',
-        'hyvinvointitv.fi',
-        'inez.fi',
-        'permanto.fi',
-        'suite.icareus.com',
-        'videos.minifiddlers.org',
-    )))
-    _VALID_URL = rf'(?P<base_url>https?://(?:www\.)?(?:{_DOMAINS}))/[^?#]+/player/[^?#]+\?(?:[^#]+&)?(?:assetId|eventId)=(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://www.helsinkikanava.fi/fi_FI/web/helsinkikanava/player/vod?assetId=68021894',
-        'md5': 'ca0b62ffc814a5411dfa6349cf5adb8a',
-        'info_dict': {
-            'id': '68021894',
-            'ext': 'mp4',
-            'title': 'Perheiden parhaaksi',
-            'description': 'md5:295785ea408e5ac00708766465cc1325',
-            'thumbnail': 'https://www.helsinkikanava.fi/image/image_gallery?img_id=68022501',
-            'upload_date': '20200924',
-            'timestamp': 1600938300,
-        },
-    }, {  # Recorded livestream
-        'url': 'https://www.helsinkikanava.fi/fi/web/helsinkikanava/player/event/view?eventId=76241489',
-        'md5': '014327e69dfa7b949fcc861f6d162d6d',
-        'info_dict': {
-            'id': '76258304',
-            'ext': 'mp4',
-            'title': 'Helsingin kaupungin ja HUSin tiedotustilaisuus koronaepidemiatilanteesta 24.11.2020',
-            'description': 'md5:3129d041c6fbbcdc7fe68d9a938fef1c',
-            'thumbnail': 'https://icareus-suite.secure2.footprint.net/image/image_gallery?img_id=76288630',
-            'upload_date': '20201124',
-            'timestamp': 1606206600,
-        },
-    }, {  # Non-m3u8 stream
-        'url': 'https://suite.icareus.com/fi/web/westend-indians/player/vod?assetId=47567389',
-        'md5': '72fc04ee971bbedc44405cdf16c990b6',
-        'info_dict': {
-            'id': '47567389',
-            'ext': 'mp4',
-            'title': 'Omatoiminen harjoittelu - Laukominen',
-            'description': '',
-            'thumbnail': 'https://suite.icareus.com/image/image_gallery?img_id=47568162',
-            'upload_date': '20200319',
-            'timestamp': 1584658080,
-        },
-    }, {
-        'url': 'https://asahitv.fi/fi/web/asahi/player/vod?assetId=89415818',
-        'only_matching': True
-    }, {
-        'url': 'https://hyvinvointitv.fi/fi/web/hyvinvointitv/player/vod?assetId=89149730',
-        'only_matching': True
-    }, {
-        'url': 'https://inez.fi/fi/web/inez-media/player/vod?assetId=71328822',
-        'only_matching': True
-    }, {
-        'url': 'https://www.permanto.fi/fi/web/alfatv/player/vod?assetId=135497515',
-        'only_matching': True
-    }, {
-        'url': 'https://videos.minifiddlers.org/web/international-minifiddlers/player/vod?assetId=1982759',
-        'only_matching': True
-    }]
-
-    def _real_extract(self, url):
-        base_url, temp_id = self._match_valid_url(url).groups()
-        webpage = self._download_webpage(url, temp_id)
-
-        video_id = self._search_regex(r"_icareus\['itemId'\]\s*=\s*'(\d+)'", webpage, 'video_id')
-        organization_id = self._search_regex(r"_icareus\['organizationId'\]\s*=\s*'(\d+)'", webpage, 'organization_id')
-
-        assets = self._download_json(
-            self._search_regex(r'var\s+publishingServiceURL\s*=\s*"(http[^"]+)";', webpage, 'api_base'),
-            video_id, data=urlencode_postdata({
-                'version': '03',
-                'action': 'getAssetPlaybackUrls',
-                'organizationId': organization_id,
-                'assetId': video_id,
-                'token': self._search_regex(r"_icareus\['token'\]\s*=\s*'([a-f0-9]+)'", webpage, 'icareus_token'),
-            }))
-
-        subtitles = {
-            remove_end(sdesc.split(' ')[0], ':'): [{'url': url_or_none(surl)}]
-            for _, sdesc, surl in assets.get('subtitles') or []
-        }
-
-        formats = [{
-            'format': item.get('name'),
-            'format_id': 'audio',
-            'vcodec': 'none',
-            'url': url_or_none(item['url']),
-            'tbr': int_or_none(self._search_regex(
-                r'\((\d+)\s*k\)', item.get('name') or '', 'audio bitrate', default=None)),
-        } for item in assets.get('audio_urls') or [] if url_or_none(item.get('url'))]
-
-        for item in assets.get('urls') or []:
-            video_url = url_or_none(item.get('url'))
-            if video_url is None:
-                continue
-            ext = determine_ext(video_url)
-            if ext == 'm3u8':
-                fmts, subs = self._extract_m3u8_formats_and_subtitles(
-                    video_url, video_id, 'mp4', m3u8_id='hls', fatal=False)
-                formats.extend(fmts)
-                self._merge_subtitles(subs, target=subtitles)
-            else:
-                fmt = item.get('name')
-                formats.append({
-                    'url': video_url,
-                    'format': fmt,
-                    'tbr': parse_bitrate(fmt),
-                    'format_id': str_or_none(item.get('id')),
-                    **parse_resolution(fmt),
-                })
-
-        info, token, live_title = self._search_json_ld(webpage, video_id, default={}), None, None
-        if not info:
-            token = self._search_regex(
-                r'data\s*:\s*{action:"getAsset".*?token:\'([a-f0-9]+)\'}', webpage, 'token', default=None)
-            if not token:
-                live_title = get_element_by_class('unpublished-info-item future-event-title', webpage)
-
-        if token:
-            metadata = self._download_json(
-                f'{base_url}/icareus-suite-api-portlet/publishing',
-                video_id, fatal=False, data=urlencode_postdata({
-                    'version': '03',
-                    'action': 'getAsset',
-                    'organizationId': organization_id,
-                    'assetId': video_id,
-                    'languageId': 'en_US',
-                    'userId': '0',
-                    'token': token,
-                })) or {}
-            info = {
-                'title': metadata.get('name'),
-                'description': metadata.get('description'),
-                'timestamp': int_or_none(metadata.get('date'), scale=1000),
-                'duration': int_or_none(metadata.get('duration')),
-                'thumbnail': url_or_none(metadata.get('thumbnailMedium')),
-            }
-        elif live_title:  # Recorded livestream
-            info = {
-                'title': live_title,
-                'description': get_element_by_class('unpublished-info-item future-event-description', webpage),
-                'timestamp': int_or_none(self._search_regex(
-                    r'var startEvent\s*=\s*(\d+);', webpage, 'uploadDate', fatal=False), scale=1000),
-            }
-
-        thumbnails = info.get('thumbnails') or [{
-            'url': url_or_none(info.get('thumbnail') or assets.get('thumbnail'))
-        }]
-
-        return merge_dicts({
-            'id': video_id,
-            'title': None,
-            'formats': formats,
-            'subtitles': subtitles,
-            'description': clean_html(info.get('description')),
-            'thumbnails': thumbnails if thumbnails[0]['url'] else None,
-        }, info)

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

@@ -1,160 +0,0 @@
-from .common import InfoExtractor
-from ..utils import ExtractorError, str_or_none, traverse_obj, unified_strdate
-from ..compat import compat_str
-
-
-class IchinanaLiveIE(InfoExtractor):
-    IE_NAME = '17live'
-    _VALID_URL = r'https?://(?:www\.)?17\.live/(?:[^/]+/)*(?:live|profile/r)/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://17.live/live/3773096',
-        'info_dict': {
-            'id': '3773096',
-            'title': '萠珈☕🤡🍫moka',
-            'is_live': True,
-            'uploader': '萠珈☕🤡🍫moka',
-            'uploader_id': '3773096',
-            'like_count': 366,
-            'view_count': 18121,
-            'timestamp': 1630569012,
-        },
-        'skip': 'running as of writing, but may be ended as of testing',
-    }, {
-        'note': 'nothing except language differs',
-        'url': 'https://17.live/ja/live/3773096',
-        'only_matching': True,
-    }]
-
-    @classmethod
-    def suitable(cls, url):
-        return not IchinanaLiveClipIE.suitable(url) and super(IchinanaLiveIE, cls).suitable(url)
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        url = 'https://17.live/live/%s' % video_id
-
-        enter = self._download_json(
-            'https://api-dsa.17app.co/api/v1/lives/%s/enter' % video_id, video_id,
-            headers={'Referer': url}, fatal=False, expected_status=420,
-            data=b'\0')
-        if enter and enter.get('message') == 'ended':
-            raise ExtractorError('This live has ended.', expected=True)
-
-        view_data = self._download_json(
-            'https://api-dsa.17app.co/api/v1/lives/%s' % video_id, video_id,
-            headers={'Referer': url})
-
-        uploader = traverse_obj(
-            view_data, ('userInfo', 'displayName'), ('userInfo', 'openID'))
-
-        video_urls = view_data.get('rtmpUrls')
-        if not video_urls:
-            raise ExtractorError('unable to extract live URL information')
-        formats = []
-        for (name, value) in video_urls[0].items():
-            if not isinstance(value, compat_str):
-                continue
-            if not value.startswith('http'):
-                continue
-            quality = -1
-            if 'web' in name:
-                quality -= 1
-            if 'High' in name:
-                quality += 4
-            if 'Low' in name:
-                quality -= 2
-            formats.append({
-                'format_id': name,
-                'url': value,
-                'quality': quality,
-                'http_headers': {'Referer': url},
-                'ext': 'flv',
-                'vcodec': 'h264',
-                'acodec': 'aac',
-            })
-
-        return {
-            'id': video_id,
-            'title': uploader or video_id,
-            'formats': formats,
-            'is_live': True,
-            'uploader': uploader,
-            'uploader_id': video_id,
-            'like_count': view_data.get('receivedLikeCount'),
-            'view_count': view_data.get('viewerCount'),
-            'thumbnail': view_data.get('coverPhoto'),
-            'description': view_data.get('caption'),
-            'timestamp': view_data.get('beginTime'),
-        }
-
-
-class IchinanaLiveClipIE(InfoExtractor):
-    IE_NAME = '17live:clip'
-    _VALID_URL = r'https?://(?:www\.)?17\.live/(?:[^/]+/)*profile/r/(?P<uploader_id>\d+)/clip/(?P<id>[^/]+)'
-    _TESTS = [{
-        'url': 'https://17.live/profile/r/1789280/clip/1bHQSK8KUieruFXaCH4A4upCzlN',
-        'info_dict': {
-            'id': '1bHQSK8KUieruFXaCH4A4upCzlN',
-            'title': 'マチコ先生🦋Class💋',
-            'description': 'マチ戦隊　第一次　バスターコール\n総額200万coin！\n動画制作@うぉーかー🌱Walker🎫',
-            'uploader_id': '1789280',
-        },
-    }, {
-        'url': 'https://17.live/ja/profile/r/1789280/clip/1bHQSK8KUieruFXaCH4A4upCzlN',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        uploader_id, video_id = self._match_valid_url(url).groups()
-        url = 'https://17.live/profile/r/%s/clip/%s' % (uploader_id, video_id)
-
-        view_data = self._download_json(
-            'https://api-dsa.17app.co/api/v1/clips/%s' % video_id, video_id,
-            headers={'Referer': url})
-
-        uploader = traverse_obj(
-            view_data, ('userInfo', 'displayName'), ('userInfo', 'name'))
-
-        formats = []
-        if view_data.get('videoURL'):
-            formats.append({
-                'id': 'video',
-                'url': view_data['videoURL'],
-                'quality': -1,
-            })
-        if view_data.get('transcodeURL'):
-            formats.append({
-                'id': 'transcode',
-                'url': view_data['transcodeURL'],
-                'quality': -1,
-            })
-        if view_data.get('srcVideoURL'):
-            # highest quality
-            formats.append({
-                'id': 'srcVideo',
-                'url': view_data['srcVideoURL'],
-                'quality': 1,
-            })
-
-        for fmt in formats:
-            fmt.update({
-                'ext': 'mp4',
-                'protocol': 'https',
-                'vcodec': 'h264',
-                'acodec': 'aac',
-                'http_headers': {'Referer': url},
-            })
-
-        return {
-            'id': video_id,
-            'title': uploader or video_id,
-            'formats': formats,
-            'uploader': uploader,
-            'uploader_id': uploader_id,
-            'like_count': view_data.get('likeCount'),
-            'view_count': view_data.get('viewCount'),
-            'thumbnail': view_data.get('imageURL'),
-            'duration': view_data.get('duration'),
-            'description': view_data.get('caption'),
-            'upload_date': unified_strdate(str_or_none(view_data.get('createdAt'))),
-        }