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

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

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

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

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

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

@@ -0,0 +1,160 @@
+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'))),
+        }