logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

orf.py (32195B)

    

  1. # coding: utf-8
  2. from __future__ import unicode_literals
  4. import base64
  5. import functools
  6. import re
  8. from .common import InfoExtractor
  9. from .youtube import YoutubeIE
  10. from ..utils import (
  11.     clean_html,
  12.     determine_ext,
  13.     ExtractorError,
  14.     float_or_none,
  15.     int_or_none,
  16.     merge_dicts,
  17.     mimetype2ext,
  18.     parse_age_limit,
  19.     parse_iso8601,
  20.     strip_jsonp,
  21.     txt_or_none,
  22.     unified_strdate,
  23.     update_url_query,
  24.     url_or_none,
  25. )
  26. from ..traversal import T, traverse_obj
  28. k_float_or_none = functools.partial(float_or_none, scale=1000)
  31. class ORFRadioBase(InfoExtractor):
  32.     STATION_INFO = {
  33.         'fm4': ('fm4', 'fm4', 'orffm4'),
  34.         'noe': ('noe', 'oe2n', 'orfnoe'),
  35.         'wien': ('wie', 'oe2w', 'orfwie'),
  36.         'burgenland': ('bgl', 'oe2b', 'orfbgl'),
  37.         'ooe': ('ooe', 'oe2o', 'orfooe'),
  38.         'steiermark': ('stm', 'oe2st', 'orfstm'),
  39.         'kaernten': ('ktn', 'oe2k', 'orfktn'),
  40.         'salzburg': ('sbg', 'oe2s', 'orfsbg'),
  41.         'tirol': ('tir', 'oe2t', 'orftir'),
  42.         'vorarlberg': ('vbg', 'oe2v', 'orfvbg'),
  43.         'oe3': ('oe3', 'oe3', 'orfoe3'),
  44.         'oe1': ('oe1', 'oe1', 'orfoe1'),
  45.     }
  46.     _ID_NAMES = ('id', 'guid', 'program')
  48.     @classmethod
  49.     def _get_item_id(cls, data):
  50.         return traverse_obj(data, *cls._ID_NAMES, expected_type=txt_or_none)
  52.     @classmethod
  53.     def _get_api_payload(cls, data, expected_id, in_payload=False):
  54.         if expected_id not in traverse_obj(data, ('payload',)[:1 if in_payload else 0] + (cls._ID_NAMES, T(txt_or_none))):
  55.             raise ExtractorError('Unexpected API data result', video_id=expected_id)
  56.         return data['payload']
  58.     @staticmethod
  59.     def _extract_podcast_upload(data):
  60.         return traverse_obj(data, {
  61.             'url': ('enclosures', 0, 'url'),
  62.             'ext': ('enclosures', 0, 'type', T(mimetype2ext)),
  63.             'filesize': ('enclosures', 0, 'length', T(int_or_none)),
  64.             'title': ('title', T(txt_or_none)),
  65.             'description': ('description', T(clean_html)),
  66.             'timestamp': (('published', 'postDate'), T(parse_iso8601)),
  67.             'duration': ('duration', T(k_float_or_none)),
  68.             'series': ('podcast', 'title'),
  69.             'uploader': ((('podcast', 'author'), 'station'), T(txt_or_none)),
  70.             'uploader_id': ('podcast', 'channel', T(txt_or_none)),
  71.         }, get_all=False)
  73.     @classmethod
  74.     def _entries(cls, data, station, item_type=None):
  75.         if item_type in ('upload', 'podcast-episode'):
  76.             yield merge_dicts({
  77.                 'id': cls._get_item_id(data),
  78.                 'ext': 'mp3',
  79.                 'vcodec': 'none',
  80.             }, cls._extract_podcast_upload(data), rev=True)
  81.             return
  83.         loop_station = cls.STATION_INFO[station][1]
  84.         for info in traverse_obj(data, ((('streams', Ellipsis), 'stream'), T(lambda v: v if v['loopStreamId'] else None))):
  85.             item_id = info['loopStreamId']
  86.             host = info.get('host') or 'loopstream01.apa.at'
  87.             yield merge_dicts({
  88.                 'id': item_id.replace('.mp3', ''),
  89.                 'ext': 'mp3',
  90.                 'url': update_url_query('https://{0}/'.format(host), {
  91.                     'channel': loop_station,
  92.                     'id': item_id,
  93.                 }),
  94.                 'vcodec': 'none',
  95.                 # '_old_archive_ids': [make_archive_id(old_ie, video_id)],
  96.             }, traverse_obj(data, {
  97.                 'title': ('title', T(txt_or_none)),
  98.                 'description': ('subtitle', T(clean_html)),
  99.                 'uploader': 'station',
  100.                 'series': ('programTitle', T(txt_or_none)),
  101.             }), traverse_obj(info, {
  102.                 'duration': (('duration',
  103.                               (None, T(lambda x: x['end'] - x['start']))),
  104.                              T(k_float_or_none), any),
  105.                 'timestamp': (('start', 'startISO'), T(parse_iso8601), any),
  106.             }))
  109. class ORFRadioIE(ORFRadioBase):
  110.     IE_NAME = 'orf:sound'
  111.     _STATION_RE = '|'.join(map(re.escape, ORFRadioBase.STATION_INFO.keys()))
  113.     _VALID_URL = (
  114.         r'https?://sound\.orf\.at/radio/(?P<station>{0})/sendung/(?P<id>\d+)(?:/(?P<show>\w+))?'.format(_STATION_RE),
  115.         r'https?://(?P<station>{0})\.orf\.at/player/(?P<date>\d{{8}})/(?P<id>\d+)'.format(_STATION_RE),
  116.     )
  118.     _TESTS = [{
  119.         'url': 'https://sound.orf.at/radio/ooe/sendung/37802/guten-morgen-oberoesterreich-am-feiertag',
  120.         'info_dict': {
  121.             'id': '37802',
  122.             'title': 'Guten Morgen Oberösterreich am Feiertag',
  123.             'description': 'Oberösterreichs meistgehörte regionale Frühsendung.\nRegionale Nachrichten zu jeder halben Stunde.\nModeration: Wolfgang Lehner\nNachrichten:  Stephan Schnabl',
  124.         },
  125.         'playlist': [{
  126.             'md5': 'f9ff8517dd681b642a2c900e2c9e6085',
  127.             'info_dict': {
  128.                 'id': '2024-05-30_0559_tl_66_7DaysThu1_443862',
  129.                 'ext': 'mp3',
  130.                 'title': 'Guten Morgen Oberösterreich am Feiertag',
  131.                 'description': 'Oberösterreichs meistgehörte regionale Frühsendung.\nRegionale Nachrichten zu jeder halben Stunde.\nModeration: Wolfgang Lehner\nNachrichten:  Stephan Schnabl',
  132.                 'timestamp': 1717041587,
  133.                 'upload_date': '20240530',
  134.                 'uploader': 'ooe',
  135.                 'duration': 14413.0,
  136.             }
  137.         }],
  138.         'skip': 'Shows from ORF Sound are only available for 30 days.'
  139.     }, {
  140.         'url': 'https://oe1.orf.at/player/20240531/758136',
  141.         'md5': '2397717aaf3ae9c22a4f090ee3b8d374',
  142.         'info_dict': {
  143.             'id': '2024-05-31_1905_tl_51_7DaysFri35_2413387',
  144.             'ext': 'mp3',
  145.             'title': '"Who Cares?"',
  146.             'description': 'Europas größte Netzkonferenz re:publica 2024',
  147.             'timestamp': 1717175100,
  148.             'upload_date': '20240531',
  149.             'uploader': 'oe1',
  150.             'duration': 1500,
  151.         },
  152.         'skip': 'Shows from ORF Sound are only available for 30 days.'
  153.     }]
  155.     def _real_extract(self, url):
  156.         m = self._match_valid_url(url)
  157.         station, show_id = m.group('station', 'id')
  158.         api_station, _, _ = self.STATION_INFO[station]
  159.         if 'date' in m.groupdict():
  160.             data = self._download_json(
  161.                 'https://audioapi.orf.at/{0}/json/4.0/broadcast/{1}/{2}?_o={3}.orf.at'.format(
  162.                     api_station, show_id, m.group('date'), station), show_id)
  163.             show_id = data['id']
  164.         else:
  165.             data = self._download_json(
  166.                 'https://audioapi.orf.at/{0}/api/json/5.0/broadcast/{1}?_o=sound.orf.at'.format(
  167.                     api_station, show_id), show_id)
  169.             data = self._get_api_payload(data, show_id, in_payload=True)
  171.         # site sends ISO8601 GMT date-times with separate TZ offset, ignored
  172.         # TODO: should `..._date` be calculated relative to TZ?
  174.         return merge_dicts(
  175.             {'_type': 'multi_video'},
  176.             self.playlist_result(
  177.                 self._entries(data, station), show_id,
  178.                 txt_or_none(data.get('title')),
  179.                 clean_html(data.get('subtitle'))))
  182. class ORFRadioCollectionIE(ORFRadioBase):
  183.     IE_NAME = 'orf:collection'
  184.     _VALID_URL = r'https?://sound\.orf\.at/collection/(?P<coll_id>\d+)(?:/(?P<item_id>\d+))?'
  186.     _TESTS = [{
  187.         'url': 'https://sound.orf.at/collection/4/61908/was-das-uberschreiten-des-15-limits-bedeutet',
  188.         'info_dict': {
  189.             'id': '2577582',
  190.         },
  191.         'playlist': [{
  192.             'md5': '5789cec7d75575ff58d19c0428c80eb3',
  193.             'info_dict': {
  194.                 'id': '2024-06-06_1659_tl_54_7DaysThu6_153926',
  195.                 'ext': 'mp3',
  196.                 'title': 'Klimakrise: Was das Überschreiten des 1,5°-Limits bedeutet',
  197.                 'timestamp': 1717686674,
  198.                 'upload_date': '20240606',
  199.                 'uploader': 'fm4',
  200.             },
  201.         }],
  202.         'skip': 'Shows from ORF Sound are only available for 30 days.'
  203.     }, {
  204.         # persistent playlist (FM4 Highlights)
  205.         'url': 'https://sound.orf.at/collection/4/',
  206.         'info_dict': {
  207.             'id': '4',
  208.         },
  209.         'playlist_mincount': 10,
  210.         'playlist_maxcount': 13,
  211.     }]
  213.     def _real_extract(self, url):
  214.         coll_id, item_id = self._match_valid_url(url).group('coll_id', 'item_id')
  215.         data = self._download_json(
  216.             'https://collector.orf.at/api/frontend/collections/{0}?_o=sound.orf.at'.format(
  217.                 coll_id), coll_id)
  218.         data = self._get_api_payload(data, coll_id, in_payload=True)
  220.         def yield_items():
  221.             for item in traverse_obj(data, (
  222.                     'content', 'items', lambda _, v: any(k in v['target']['params'] for k in self._ID_NAMES))):
  223.                 if item_id is None or item_id == txt_or_none(item.get('id')):
  224.                     target = item['target']
  225.                     typed_item_id = self._get_item_id(target['params'])
  226.                     station = target['params'].get('station')
  227.                     item_type = target.get('type')
  228.                     if typed_item_id and (station or item_type):
  229.                         yield station, typed_item_id, item_type
  230.                     if item_id is not None:
  231.                         break
  232.             else:
  233.                 if item_id is not None:
  234.                     raise ExtractorError('Item not found in collection',
  235.                                          video_id=coll_id, expected=True)
  237.         def item_playlist(station, typed_item_id, item_type):
  238.             if item_type == 'upload':
  239.                 item_data = self._download_json('https://audioapi.orf.at/radiothek/api/2.0/upload/{0}?_o=sound.orf.at'.format(
  240.                     typed_item_id), typed_item_id)
  241.             elif item_type == 'podcast-episode':
  242.                 item_data = self._download_json('https://audioapi.orf.at/radiothek/api/2.0/episode/{0}?_o=sound.orf.at'.format(
  243.                     typed_item_id), typed_item_id)
  244.             else:
  245.                 api_station, _, _ = self.STATION_INFO[station]
  246.                 item_data = self._download_json(
  247.                     'https://audioapi.orf.at/{0}/api/json/5.0/{1}/{2}?_o=sound.orf.at'.format(
  248.                         api_station, item_type or 'broadcastitem', typed_item_id), typed_item_id)
  250.             item_data = self._get_api_payload(item_data, typed_item_id, in_payload=True)
  252.             return merge_dicts(
  253.                 {'_type': 'multi_video'},
  254.                 self.playlist_result(
  255.                     self._entries(item_data, station, item_type), typed_item_id,
  256.                     txt_or_none(data.get('title')),
  257.                     clean_html(data.get('subtitle'))))
  259.         def yield_item_entries():
  260.             for station, typed_id, item_type in yield_items():
  261.                 yield item_playlist(station, typed_id, item_type)
  263.         if item_id is not None:
  264.             # coll_id = '/'.join((coll_id, item_id))
  265.             return next(yield_item_entries())
  267.         return self.playlist_result(yield_item_entries(), coll_id, data.get('title'))
  270. class ORFPodcastIE(ORFRadioBase):
  271.     IE_NAME = 'orf:podcast'
  272.     _STATION_RE = '|'.join(map(re.escape, (x[0] for x in ORFRadioBase.STATION_INFO.values()))) + '|tv'
  273.     _VALID_URL = r'https?://sound\.orf\.at/podcast/(?P<station>{0})/(?P<show>[\w-]+)/(?P<id>[\w-]+)'.format(_STATION_RE)
  274.     _TESTS = [{
  275.         'url': 'https://sound.orf.at/podcast/stm/der-kraeutertipp-von-christine-lackner/rotklee',
  276.         'md5': '1f2bab2ba90c2ce0c2754196ea78b35f',
  277.         'info_dict': {
  278.             'id': 'der-kraeutertipp-von-christine-lackner/rotklee',
  279.             'ext': 'mp3',
  280.             'title': 'Rotklee',
  281.             'description': 'In der Natur weit verbreitet - in der Medizin längst anerkennt: Rotklee. Dieser Podcast begleitet die Sendung "Radio Steiermark am Vormittag", Radio Steiermark, 28. Mai 2024.',
  282.             'timestamp': 1716891761,
  283.             'upload_date': '20240528',
  284.             'uploader_id': 'stm_kraeutertipp',
  285.             'uploader': 'ORF Radio Steiermark',
  286.             'duration': 101,
  287.             'series': 'Der Kräutertipp von Christine Lackner',
  288.         },
  289.         'skip': 'ORF podcasts are only available for a limited time'
  290.     }]
  292.     _ID_NAMES = ('slug', 'guid')
  294.     def _real_extract(self, url):
  295.         station, show, show_id = self._match_valid_url(url).group('station', 'show', 'id')
  296.         data = self._download_json(
  297.             'https://audioapi.orf.at/radiothek/api/2.0/podcast/{0}/{1}/{2}'.format(
  298.                 station, show, show_id), show_id)
  299.         data = self._get_api_payload(data, show_id, in_payload=True)
  301.         return merge_dicts({
  302.             'id': '/'.join((show, show_id)),
  303.             'ext': 'mp3',
  304.             'vcodec': 'none',
  305.         }, self._extract_podcast_upload(data), rev=True)
  308. class ORFIPTVBase(InfoExtractor):
  309.     _TITLE_STRIP_RE = ''
  311.     def _extract_video(self, video_id, webpage, fatal=False):
  313.         data = self._download_json(
  314.             'http://bits.orf.at/filehandler/static-api/json/current/data.json?file=%s' % video_id,
  315.             video_id)[0]
  317.         video = traverse_obj(data, (
  318.             'sources', ('default', 'q8c'),
  319.             T(lambda x: x if x['loadBalancerUrl'] else None),
  320.             any))
  322.         load_balancer_url = video['loadBalancerUrl']
  324.         try:
  325.             rendition = self._download_json(
  326.                 load_balancer_url, video_id, transform_source=strip_jsonp)
  327.         except ExtractorError:
  328.             rendition = None
  330.         if not rendition:
  331.             rendition = {
  332.                 'redirect': {
  333.                     'smil': re.sub(
  334.                         r'(/)jsonp(/.+\.)mp4$', r'\1dash\2smil/manifest.mpd',
  335.                         load_balancer_url),
  336.                 },
  337.             }
  339.         f = traverse_obj(video, {
  340.             'abr': ('audioBitrate', T(int_or_none)),
  341.             'vbr': ('bitrate', T(int_or_none)),
  342.             'fps': ('videoFps', T(int_or_none)),
  343.             'width': ('videoWidth', T(int_or_none)),
  344.             'height': ('videoHeight', T(int_or_none)),
  345.         })
  347.         formats = []
  348.         for format_id, format_url in traverse_obj(rendition, (
  349.                 'redirect', T(dict.items), Ellipsis)):
  350.             if format_id == 'rtmp':
  351.                 ff = f.copy()
  352.                 ff.update({
  353.                     'url': format_url,
  354.                     'format_id': format_id,
  355.                 })
  356.                 formats.append(ff)
  357.             elif determine_ext(format_url) == 'f4m':
  358.                 formats.extend(self._extract_f4m_formats(
  359.                     format_url, video_id, f4m_id=format_id))
  360.             elif determine_ext(format_url) == 'm3u8':
  361.                 formats.extend(self._extract_m3u8_formats(
  362.                     format_url, video_id, 'mp4', m3u8_id=format_id,
  363.                     entry_protocol='m3u8_native'))
  364.             elif determine_ext(format_url) == 'mpd':
  365.                 formats.extend(self._extract_mpd_formats(
  366.                     format_url, video_id, mpd_id=format_id))
  368.         if formats or fatal:
  369.             self._sort_formats(formats)
  370.         else:
  371.             return
  373.         return merge_dicts({
  374.             'id': video_id,
  375.             'title': re.sub(self._TITLE_STRIP_RE, '', self._og_search_title(webpage)),
  376.             'description': self._og_search_description(webpage),
  377.             'upload_date': unified_strdate(self._html_search_meta(
  378.                 'dc.date', webpage, 'upload date', fatal=False)),
  379.             'formats': formats,
  380.         }, traverse_obj(data, {
  381.             'duration': ('duration', T(k_float_or_none)),
  382.             'thumbnail': ('sources', 'default', 'preview', T(url_or_none)),
  383.         }), rev=True)
  386. class ORFIPTVIE(ORFIPTVBase):
  387.     IE_NAME = 'orf:iptv'
  388.     IE_DESC = 'iptv.ORF.at'
  389.     _WORKING = False  # URLs redirect to orf.at/
  390.     _VALID_URL = r'https?://iptv\.orf\.at/(?:#/)?stories/(?P<id>\d+)'
  391.     _TITLE_STRIP_RE = r'\s+-\s+iptv\.ORF\.at\S*$'
  393.     _TEST = {
  394.         'url': 'http://iptv.orf.at/stories/2275236/',
  395.         'md5': 'c8b22af4718a4b4af58342529453e3e5',
  396.         'info_dict': {
  397.             'id': '350612',
  398.             'ext': 'flv',
  399.             'title': 'Weitere Evakuierungen um Vulkan Calbuco',
  400.             'description': 'md5:d689c959bdbcf04efeddedbf2299d633',
  401.             'duration': 68.197,
  402.             'thumbnail': r're:^https?://.*\.jpg$',
  403.             'upload_date': '20150425',
  404.         },
  405.     }
  407.     def _real_extract(self, url):
  408.         story_id = self._match_id(url)
  410.         webpage = self._download_webpage(
  411.             'http://iptv.orf.at/stories/%s' % story_id, story_id)
  413.         video_id = self._search_regex(
  414.             r'data-video(?:id)?="(\d+)"', webpage, 'video id')
  416.         return self._extract_video(video_id, webpage)
  419. class ORFFM4StoryIE(ORFIPTVBase):
  420.     IE_NAME = 'orf:fm4:story'
  421.     IE_DESC = 'fm4.orf.at stories'
  422.     _VALID_URL = r'https?://fm4\.orf\.at/stories/(?P<id>\d+)'
  423.     _TITLE_STRIP_RE = r'\s+-\s+fm4\.ORF\.at\s*$'
  425.     _TESTS = [{
  426.         'url': 'https://fm4.orf.at/stories/3041554/',
  427.         'add_ie': ['Youtube'],
  428.         'info_dict': {
  429.             'id': '3041554',
  430.             'title': 'Is The EU Green Deal In Mortal Danger?',
  431.         },
  432.         'playlist_count': 4,
  433.         'params': {
  434.             'format': 'bestvideo',
  435.         },
  436.     }, {
  437.         'url': 'http://fm4.orf.at/stories/2865738/',
  438.         'info_dict': {
  439.             'id': '2865738',
  440.             'title': 'Manu Delago und Inner Tongue live',
  441.         },
  442.         'playlist': [{
  443.             'md5': 'e1c2c706c45c7b34cf478bbf409907ca',
  444.             'info_dict': {
  445.                 'id': '547792',
  446.                 'ext': 'flv',
  447.                 'title': 'Manu Delago und Inner Tongue live',
  448.                 'description': 'Manu Delago und Inner Tongue haben bei der FM4 Soundpark Session live alles gegeben. Hier gibt es Fotos und die gesamte Session als Video.',
  449.                 'duration': 1748.52,
  450.                 'thumbnail': r're:^https?://.*\.jpg$',
  451.                 'upload_date': '20170913',
  452.             },
  453.         }, {
  454.             'md5': 'c6dd2179731f86f4f55a7b49899d515f',
  455.             'info_dict': {
  456.                 'id': '547798',
  457.                 'ext': 'flv',
  458.                 'title': 'Manu Delago und Inner Tongue https://vod-ww.mdn.ors.at/cms-worldwide_episodes_nas/_definst_/nas/cms-worldwide_episodes/online/14228823_0005.smil/chunklist_b992000_vo.m3u8live (2)',
  459.                 'duration': 1504.08,
  460.                 'thumbnail': r're:^https?://.*\.jpg$',
  461.                 'upload_date': '20170913',
  462.                 'description': 'Manu Delago und Inner Tongue haben bei der FM4 Soundpark Session live alles gegeben. Hier gibt es Fotos und die gesamte Session als Video.',
  463.             },
  464.         }],
  465.         'skip': 'Videos gone',
  466.     }]
  468.     def _real_extract(self, url):
  469.         story_id = self._match_id(url)
  470.         webpage = self._download_webpage(url, story_id)
  472.         entries = []
  473.         seen_ids = set()
  474.         for idx, video_id in enumerate(re.findall(r'data-video(?:id)?="(\d+)"', webpage)):
  475.             if video_id in seen_ids:
  476.                 continue
  477.             seen_ids.add(video_id)
  478.             entry = self._extract_video(video_id, webpage, fatal=False)
  479.             if not entry:
  480.                 continue
  482.             if idx >= 1:
  483.                 # Titles are duplicates, make them unique
  484.                 entry['title'] = '%s (%d)' % (entry['title'], idx)
  486.             entries.append(entry)
  488.         seen_ids = set()
  489.         for yt_id in re.findall(
  490.                 r'data-id\s*=\s*["\']([\w-]+)[^>]+\bclass\s*=\s*["\']youtube\b',
  491.                 webpage):
  492.             if yt_id in seen_ids:
  493.                 continue
  494.             seen_ids.add(yt_id)
  495.             if YoutubeIE.suitable(yt_id):
  496.                 entries.append(self.url_result(yt_id, ie='Youtube', video_id=yt_id))
  498.         return self.playlist_result(
  499.             entries, story_id,
  500.             re.sub(self._TITLE_STRIP_RE, '', self._og_search_title(webpage, default='') or None))
  503. class ORFONBase(InfoExtractor):
  504.     _ENC_PFX = '3dSlfek03nsLKdj4Jsd'
  505.     _API_PATH = 'episode'
  507.     def _call_api(self, video_id, **kwargs):
  508.         encrypted_id = base64.b64encode('{0}{1}'.format(
  509.             self._ENC_PFX, video_id).encode('utf-8')).decode('ascii')
  510.         return self._download_json(
  511.             'https://api-tvthek.orf.at/api/v4.3/public/{0}/encrypted/{1}'.format(
  512.                 self._API_PATH, encrypted_id),
  513.             video_id, **kwargs)
  515.     @classmethod
  516.     def _parse_metadata(cls, api_json):
  517.         return traverse_obj(api_json, {
  518.             'id': ('id', T(int), T(txt_or_none)),
  519.             'age_limit': ('age_classification', T(parse_age_limit)),
  520.             'duration': ((('exact_duration', T(k_float_or_none)),
  521.                           ('duration_second', T(float_or_none))),),
  522.             'title': (('title', 'headline'), T(txt_or_none)),
  523.             'description': (('description', 'teaser_text'), T(txt_or_none)),
  524.             # 'media_type': ('video_type', T(txt_or_none)),
  525.             'thumbnail': ('_embedded', 'image', 'public_urls', 'highlight_teaser', 'url', T(url_or_none)),
  526.             'timestamp': (('date', 'episode_date'), T(parse_iso8601)),
  527.             'release_timestamp': ('release_date', T(parse_iso8601)),
  528.             # 'modified_timestamp': ('updated_at', T(parse_iso8601)),
  529.         }, get_all=False)
  531.     def _extract_video(self, video_id, segment_id):
  532.         # Not a segmented episode: return single video
  533.         # Segmented episode without valid segment id: return entire playlist
  534.         # Segmented episode with valid segment id and yes-playlist: return entire playlist
  535.         # Segmented episode with valid segment id and no-playlist: return single video corresponding to segment id
  536.         # If a multi_video playlist would be returned, but an unsegmented source exists, that source is chosen instead.
  538.         api_json = self._call_api(video_id)
  540.         if traverse_obj(api_json, 'is_drm_protected'):
  541.             self.report_drm(video_id)
  543.         # updates formats, subtitles
  544.         def extract_sources(src_json, video_id):
  545.             for manifest_type in traverse_obj(src_json, ('sources', T(dict.keys), Ellipsis)):
  546.                 for manifest_url in traverse_obj(src_json, ('sources', manifest_type, Ellipsis, 'src', T(url_or_none))):
  547.                     if manifest_type == 'hls':
  548.                         fmts, subs = self._extract_m3u8_formats(
  549.                             manifest_url, video_id, fatal=False, m3u8_id='hls',
  550.                             ext='mp4', entry_protocol='m3u8_native'), {}
  551.                         for f in fmts:
  552.                             if '_vo.' in f['url']:
  553.                                 f['acodec'] = 'none'
  554.                     elif manifest_type == 'dash':
  555.                         fmts, subs = self._extract_mpd_formats_and_subtitles(
  556.                             manifest_url, video_id, fatal=False, mpd_id='dash')
  557.                     else:
  558.                         continue
  559.                     formats.extend(fmts)
  560.                     self._merge_subtitles(subs, target=subtitles)
  562.         formats, subtitles = [], {}
  563.         if segment_id is None:
  564.             extract_sources(api_json, video_id)
  565.         if not formats:
  566.             segments = traverse_obj(api_json, (
  567.                 '_embedded', 'segments', lambda _, v: v['id']))
  568.             if len(segments) > 1 and segment_id is not None:
  569.                 if not self._yes_playlist(video_id, segment_id, playlist_label='collection', video_label='segment'):
  570.                     segments = [next(s for s in segments if txt_or_none(s['id']) == segment_id)]
  572.             entries = []
  573.             for seg in segments:
  574.                 formats, subtitles = [], {}
  575.                 extract_sources(seg, segment_id)
  576.                 self._sort_formats(formats)
  577.                 entries.append(merge_dicts({
  578.                     'formats': formats,
  579.                     'subtitles': subtitles,
  580.                 }, self._parse_metadata(seg), rev=True))
  581.             result = merge_dicts(
  582.                 {'_type': 'multi_video' if len(entries) > 1 else 'playlist'},
  583.                 self._parse_metadata(api_json),
  584.                 self.playlist_result(entries, video_id))
  585.             # not yet processed in core for playlist/multi
  586.             self._downloader._fill_common_fields(result)
  587.             return result
  588.         else:
  589.             self._sort_formats(formats)
  591.         for sub_url in traverse_obj(api_json, (
  592.                 '_embedded', 'subtitle',
  593.                 ('xml_url', 'sami_url', 'stl_url', 'ttml_url', 'srt_url', 'vtt_url'),
  594.                 T(url_or_none))):
  595.             self._merge_subtitles({'de': [{'url': sub_url}]}, target=subtitles)
  597.         return merge_dicts({
  598.             'id': video_id,
  599.             'formats': formats,
  600.             'subtitles': subtitles,
  601.             # '_old_archive_ids': [self._downloader._make_archive_id({'ie_key': 'ORFTVthek', 'id': video_id})],
  602.         }, self._parse_metadata(api_json), rev=True)
  604.     def _real_extract(self, url):
  605.         video_id, segment_id = self._match_valid_url(url).group('id', 'segment')
  606.         webpage = self._download_webpage(url, video_id)
  608.         # ORF doesn't like 410 or 404
  609.         if self._search_regex(r'<div\b[^>]*>\s*(Nicht mehr verfügbar)\s*</div>', webpage, 'Availability', default=False):
  610.             raise ExtractorError('Content is no longer available', expected=True, video_id=video_id)
  612.         return merge_dicts({
  613.             'id': video_id,
  614.             'title': self._html_search_meta(['og:title', 'twitter:title'], webpage, default=None),
  615.             'description': self._html_search_meta(
  616.                 ['description', 'og:description', 'twitter:description'], webpage, default=None),
  617.         }, self._search_json_ld(webpage, video_id, default={}),
  618.             self._extract_video(video_id, segment_id),
  619.             rev=True)
  622. class ORFONIE(ORFONBase):
  623.     IE_NAME = 'orf:on'
  624.     _VALID_URL = r'https?://on\.orf\.at/video/(?P<id>\d+)(?:/(?P<segment>\d+))?'
  625.     _TESTS = [{
  626.         'url': 'https://on.orf.at/video/14210000/school-of-champions-48',
  627.         'info_dict': {
  628.             'id': '14210000',
  629.             'ext': 'mp4',
  630.             'duration': 2651.08,
  631.             'thumbnail': 'https://api-tvthek.orf.at/assets/segments/0167/98/thumb_16697671_segments_highlight_teaser.jpeg',
  632.             'title': 'School of Champions (4/8)',
  633.             'description': r're:(?s)Luca hat sein ganzes Leben in den Bergen Südtirols verbracht und ist bei seiner Mutter aufgewachsen, .{1029} Leo$',
  634.             # 'media_type': 'episode',
  635.             'timestamp': 1706558922,
  636.             'upload_date': '20240129',
  637.             'release_timestamp': 1706472362,
  638.             'release_date': '20240128',
  639.             # 'modified_timestamp': 1712756663,
  640.             # 'modified_date': '20240410',
  641.             # '_old_archive_ids': ['orftvthek 14210000'],
  642.         },
  643.         'params': {
  644.             'format': 'bestvideo',
  645.         },
  646.         'skip': 'Available until 2024-08-12',
  647.     }, {
  648.         'url': 'https://on.orf.at/video/3220355',
  649.         'md5': '925a93b2b9a37da5c9b979d7cf71aa2e',
  650.         'info_dict': {
  651.             'id': '3220355',
  652.             'ext': 'mp4',
  653.             'duration': 445.04,
  654.             'thumbnail': 'https://api-tvthek.orf.at/assets/segments/0002/60/thumb_159573_segments_highlight_teaser.png',
  655.             'title': '50 Jahre Burgenland: Der Festumzug',
  656.             'description': r're:(?s)Aus allen Landesteilen zogen festlich geschmückte Wagen und Musikkapellen .{270} Jenakowitsch$',
  657.             # 'media_type': 'episode',
  658.             'timestamp': 52916400,
  659.             'upload_date': '19710905',
  660.             'release_timestamp': 52916400,
  661.             'release_date': '19710905',
  662.             # 'modified_timestamp': 1498536049,
  663.             # 'modified_date': '20170627',
  664.             # '_old_archive_ids': ['orftvthek 3220355'],
  665.         },
  666.     }, {
  667.         # Video with multiple segments selecting the second segment
  668.         'url': 'https://on.orf.at/video/14226549/15639808/jugendbande-einbrueche-aus-langeweile',
  669.         'md5': 'fc151bba8c05ea77ab5693617e4a33d3',
  670.         'info_dict': {
  671.             'id': '15639808',
  672.             'ext': 'mp4',
  673.             'duration': 97.707,
  674.             'thumbnail': 'https://api-tvthek.orf.at/assets/segments/0175/43/thumb_17442704_segments_highlight_teaser.jpg',
  675.             'title': 'Jugendbande: Einbrüche aus Langeweile',
  676.             'description': r're:Jugendbande: Einbrüche aus Langeweile \| Neuer Kinder- und .{259} Wanda$',
  677.             # 'media_type': 'segment',
  678.             'timestamp': 1715792400,
  679.             'upload_date': '20240515',
  680.             # 'modified_timestamp': 1715794394,
  681.             # 'modified_date': '20240515',
  682.             # '_old_archive_ids': ['orftvthek 15639808'],
  683.         },
  684.         'params': {
  685.             'noplaylist': True,
  686.             'format': 'bestvideo',
  687.         },
  688.         'skip': 'Available until 2024-06-14',
  689.     }, {
  690.         # Video with multiple segments and no combined version
  691.         'url': 'https://on.orf.at/video/14227864/formel-1-grosser-preis-von-monaco-2024',
  692.         'info_dict': {
  693.             '_type': 'multi_video',
  694.             'id': '14227864',
  695.             'duration': 18410.52,
  696.             'thumbnail': 'https://api-tvthek.orf.at/assets/segments/0176/04/thumb_17503881_segments_highlight_teaser.jpg',
  697.             'title': 'Formel 1: Großer Preis von Monaco 2024',
  698.             'description': 'md5:aeeb010710ccf70ce28ccb4482243d4f',
  699.             # 'media_type': 'episode',
  700.             'timestamp': 1716721200,
  701.             'upload_date': '20240526',
  702.             'release_timestamp': 1716721802,
  703.             'release_date': '20240526',
  704.             # 'modified_timestamp': 1716884702,
  705.             # 'modified_date': '20240528',
  706.         },
  707.         'playlist_count': 42,
  708.         'skip': 'Gone: Nicht mehr verfügbar',
  709.     }, {
  710.         # Video with multiple segments, but with combined version
  711.         'url': 'https://on.orf.at/video/14228172',
  712.         'info_dict': {
  713.             'id': '14228172',
  714.             'ext': 'mp4',
  715.             'duration': 3294.878,
  716.             'thumbnail': 'https://api-tvthek.orf.at/assets/segments/0176/29/thumb_17528242_segments_highlight_teaser.jpg',
  717.             'title': 'Willkommen Österreich mit Stermann & Grissemann',
  718.             'description': r're:Zum Saisonfinale freuen sich die urlaubsreifen Gastgeber Stermann und .{1863} Geschichten\.$',
  719.             # 'media_type': 'episode',
  720.             'timestamp': 1716926584,
  721.             'upload_date': '20240528',
  722.             'release_timestamp': 1716919202,
  723.             'release_date': '20240528',
  724.             # 'modified_timestamp': 1716968045,
  725.             # 'modified_date': '20240529',
  726.             # '_old_archive_ids': ['orftvthek 14228172'],
  727.         },
  728.         'params': {
  729.             'format': 'bestvideo',
  730.         },
  731.         'skip': 'Gone: Nicht mehr verfügbar',
  732.     }]
  735. class ORFONLiveIE(ORFONBase):
  736.     _ENC_PFX = '8876324jshjd7293ktd'
  737.     _API_PATH = 'livestream'
  738.     _VALID_URL = r'https?://on\.orf\.at/livestream/(?P<id>\d+)(?:/(?P<segment>\d+))?'
  739.     _TESTS = [{
  740.         'url': 'https://on.orf.at/livestream/14320204/pressekonferenz-neos-zu-aktuellen-entwicklungen',
  741.         'info_dict': {
  742.             'id': '14320204',
  743.             'ext': 'mp4',
  744.             'title': 'Pressekonferenz: Neos zu aktuellen Entwicklungen',
  745.             'description': r're:(?s)Neos-Chefin Beate Meinl-Reisinger informi.{598}ng\."',
  746.             'timestamp': 1716886335,
  747.             'upload_date': '20240528',
  748.             # 'modified_timestamp': 1712756663,
  749.             # 'modified_date': '20240410',
  750.             # '_old_archive_ids': ['orftvthek 14210000'],
  751.         },
  752.         'params': {
  753.             'format': 'bestvideo',
  754.         },
  755.     }]
  757.     @classmethod
  758.     def _parse_metadata(cls, api_json):
  759.         return merge_dicts(
  760.             super(ORFONLiveIE, cls)._parse_metadata(api_json),
  761.             traverse_obj(api_json, {
  762.                 'timestamp': ('updated_at', T(parse_iso8601)),
  763.                 'release_timestamp': ('start', T(parse_iso8601)),
  764.                 'is_live': True,
  765.             }))