logo

youtube-dl

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

tvnow.py (18470B)

    

  1. # coding: utf-8
  2. from __future__ import unicode_literals
  4. import re
  6. from .common import InfoExtractor
  7. from ..compat import compat_str
  8. from ..utils import (
  9.     ExtractorError,
  10.     int_or_none,
  11.     parse_iso8601,
  12.     parse_duration,
  13.     str_or_none,
  14.     update_url_query,
  15.     urljoin,
  16. )
  19. class TVNowBaseIE(InfoExtractor):
  20.     _VIDEO_FIELDS = (
  21.         'id', 'title', 'free', 'geoblocked', 'articleLong', 'articleShort',
  22.         'broadcastStartDate', 'isDrm', 'duration', 'season', 'episode',
  23.         'manifest.dashclear', 'manifest.hlsclear', 'manifest.smoothclear',
  24.         'format.title', 'format.defaultImage169Format', 'format.defaultImage169Logo')
  26.     def _call_api(self, path, video_id, query):
  27.         return self._download_json(
  28.             'https://api.tvnow.de/v3/' + path, video_id, query=query)
  30.     def _extract_video(self, info, display_id):
  31.         video_id = compat_str(info['id'])
  32.         title = info['title']
  34.         paths = []
  35.         for manifest_url in (info.get('manifest') or {}).values():
  36.             if not manifest_url:
  37.                 continue
  38.             manifest_url = update_url_query(manifest_url, {'filter': ''})
  39.             path = self._search_regex(r'https?://[^/]+/(.+?)\.ism/', manifest_url, 'path')
  40.             if path in paths:
  41.                 continue
  42.             paths.append(path)
  44.             def url_repl(proto, suffix):
  45.                 return re.sub(
  46.                     r'(?:hls|dash|hss)([.-])', proto + r'\1', re.sub(
  47.                         r'\.ism/(?:[^.]*\.(?:m3u8|mpd)|[Mm]anifest)',
  48.                         '.ism/' + suffix, manifest_url))
  50.             def make_urls(proto, suffix):
  51.                 urls = [url_repl(proto, suffix)]
  52.                 hd_url = urls[0].replace('/manifest/', '/ngvod/')
  53.                 if hd_url != urls[0]:
  54.                     urls.append(hd_url)
  55.                 return urls
  57.             for man_url in make_urls('dash', '.mpd'):
  58.                 formats = self._extract_mpd_formats(
  59.                     man_url, video_id, mpd_id='dash', fatal=False)
  60.             for man_url in make_urls('hss', 'Manifest'):
  61.                 formats.extend(self._extract_ism_formats(
  62.                     man_url, video_id, ism_id='mss', fatal=False))
  63.             for man_url in make_urls('hls', '.m3u8'):
  64.                 formats.extend(self._extract_m3u8_formats(
  65.                     man_url, video_id, 'mp4', 'm3u8_native', m3u8_id='hls',
  66.                     fatal=False))
  67.             if formats:
  68.                 break
  69.         else:
  70.             if info.get('isDrm'):
  71.                 raise ExtractorError(
  72.                     'Video %s is DRM protected' % video_id, expected=True)
  73.             if info.get('geoblocked'):
  74.                 raise self.raise_geo_restricted()
  75.             if not info.get('free', True):
  76.                 raise ExtractorError(
  77.                     'Video %s is not available for free' % video_id, expected=True)
  78.         self._sort_formats(formats)
  80.         description = info.get('articleLong') or info.get('articleShort')
  81.         timestamp = parse_iso8601(info.get('broadcastStartDate'), ' ')
  82.         duration = parse_duration(info.get('duration'))
  84.         f = info.get('format', {})
  86.         thumbnails = [{
  87.             'url': 'https://aistvnow-a.akamaihd.net/tvnow/movie/%s' % video_id,
  88.         }]
  89.         thumbnail = f.get('defaultImage169Format') or f.get('defaultImage169Logo')
  90.         if thumbnail:
  91.             thumbnails.append({
  92.                 'url': thumbnail,
  93.             })
  95.         return {
  96.             'id': video_id,
  97.             'display_id': display_id,
  98.             'title': title,
  99.             'description': description,
  100.             'thumbnails': thumbnails,
  101.             'timestamp': timestamp,
  102.             'duration': duration,
  103.             'series': f.get('title'),
  104.             'season_number': int_or_none(info.get('season')),
  105.             'episode_number': int_or_none(info.get('episode')),
  106.             'episode': title,
  107.             'formats': formats,
  108.         }
  111. class TVNowIE(TVNowBaseIE):
  112.     _VALID_URL = r'''(?x)
  113.                     https?://
  114.                         (?:www\.)?tvnow\.(?:de|at|ch)/(?P<station>[^/]+)/
  115.                         (?P<show_id>[^/]+)/
  116.                         (?!(?:list|jahr)(?:/|$))(?P<id>[^/?\#&]+)
  117.                     '''
  119.     @classmethod
  120.     def suitable(cls, url):
  121.         return (False if TVNowNewIE.suitable(url) or TVNowSeasonIE.suitable(url) or TVNowAnnualIE.suitable(url) or TVNowShowIE.suitable(url)
  122.                 else super(TVNowIE, cls).suitable(url))
  124.     _TESTS = [{
  125.         'url': 'https://www.tvnow.de/rtl2/grip-das-motormagazin/der-neue-porsche-911-gt-3/player',
  126.         'info_dict': {
  127.             'id': '331082',
  128.             'display_id': 'grip-das-motormagazin/der-neue-porsche-911-gt-3',
  129.             'ext': 'mp4',
  130.             'title': 'Der neue Porsche 911 GT 3',
  131.             'description': 'md5:6143220c661f9b0aae73b245e5d898bb',
  132.             'timestamp': 1495994400,
  133.             'upload_date': '20170528',
  134.             'duration': 5283,
  135.             'series': 'GRIP - Das Motormagazin',
  136.             'season_number': 14,
  137.             'episode_number': 405,
  138.             'episode': 'Der neue Porsche 911 GT 3',
  139.         },
  140.     }, {
  141.         # rtl2
  142.         'url': 'https://www.tvnow.de/rtl2/armes-deutschland/episode-0008/player',
  143.         'only_matching': True,
  144.     }, {
  145.         # rtlnitro
  146.         'url': 'https://www.tvnow.de/nitro/alarm-fuer-cobra-11-die-autobahnpolizei/auf-eigene-faust-pilot/player',
  147.         'only_matching': True,
  148.     }, {
  149.         # superrtl
  150.         'url': 'https://www.tvnow.de/superrtl/die-lustigsten-schlamassel-der-welt/u-a-ketchup-effekt/player',
  151.         'only_matching': True,
  152.     }, {
  153.         # ntv
  154.         'url': 'https://www.tvnow.de/ntv/startup-news/goetter-in-weiss/player',
  155.         'only_matching': True,
  156.     }, {
  157.         # vox
  158.         'url': 'https://www.tvnow.de/vox/auto-mobil/neues-vom-automobilmarkt-2017-11-19-17-00-00/player',
  159.         'only_matching': True,
  160.     }, {
  161.         # rtlplus
  162.         'url': 'https://www.tvnow.de/rtlplus/op-ruft-dr-bruckner/die-vernaehte-frau/player',
  163.         'only_matching': True,
  164.     }, {
  165.         'url': 'https://www.tvnow.de/rtl2/grip-das-motormagazin/der-neue-porsche-911-gt-3',
  166.         'only_matching': True,
  167.     }]
  169.     def _real_extract(self, url):
  170.         mobj = re.match(self._VALID_URL, url)
  171.         display_id = '%s/%s' % mobj.group(2, 3)
  173.         info = self._call_api(
  174.             'movies/' + display_id, display_id, query={
  175.                 'fields': ','.join(self._VIDEO_FIELDS),
  176.             })
  178.         return self._extract_video(info, display_id)
  181. class TVNowNewIE(InfoExtractor):
  182.     _VALID_URL = r'''(?x)
  183.                     (?P<base_url>https?://
  184.                         (?:www\.)?tvnow\.(?:de|at|ch)/
  185.                         (?:shows|serien))/
  186.                         (?P<show>[^/]+)-\d+/
  187.                         [^/]+/
  188.                         episode-\d+-(?P<episode>[^/?$&]+)-(?P<id>\d+)
  189.                     '''
  191.     _TESTS = [{
  192.         'url': 'https://www.tvnow.de/shows/grip-das-motormagazin-1669/2017-05/episode-405-der-neue-porsche-911-gt-3-331082',
  193.         'only_matching': True,
  194.     }]
  196.     def _real_extract(self, url):
  197.         mobj = re.match(self._VALID_URL, url)
  198.         base_url = re.sub(r'(?:shows|serien)', '_', mobj.group('base_url'))
  199.         show, episode = mobj.group('show', 'episode')
  200.         return self.url_result(
  201.             # Rewrite new URLs to the old format and use extraction via old API
  202.             # at api.tvnow.de as a loophole for bypassing premium content checks
  203.             '%s/%s/%s' % (base_url, show, episode),
  204.             ie=TVNowIE.ie_key(), video_id=mobj.group('id'))
  207. class TVNowNewBaseIE(InfoExtractor):
  208.     def _call_api(self, path, video_id, query={}):
  209.         result = self._download_json(
  210.             'https://apigw.tvnow.de/module/' + path, video_id, query=query)
  211.         error = result.get('error')
  212.         if error:
  213.             raise ExtractorError(
  214.                 '%s said: %s' % (self.IE_NAME, error), expected=True)
  215.         return result
  218. r"""
  219. TODO: new apigw.tvnow.de based version of TVNowIE. Replace old TVNowIE with it
  220. when api.tvnow.de is shut down. This version can't bypass premium checks though.
  221. class TVNowIE(TVNowNewBaseIE):
  222.     _VALID_URL = r'''(?x)
  223.                     https?://
  224.                         (?:www\.)?tvnow\.(?:de|at|ch)/
  225.                         (?:shows|serien)/[^/]+/
  226.                         (?:[^/]+/)+
  227.                         (?P<display_id>[^/?$&]+)-(?P<id>\d+)
  228.                     '''
  230.     _TESTS = [{
  231.         # episode with annual navigation
  232.         'url': 'https://www.tvnow.de/shows/grip-das-motormagazin-1669/2017-05/episode-405-der-neue-porsche-911-gt-3-331082',
  233.         'info_dict': {
  234.             'id': '331082',
  235.             'display_id': 'grip-das-motormagazin/der-neue-porsche-911-gt-3',
  236.             'ext': 'mp4',
  237.             'title': 'Der neue Porsche 911 GT 3',
  238.             'description': 'md5:6143220c661f9b0aae73b245e5d898bb',
  239.             'thumbnail': r're:^https?://.*\.jpg$',
  240.             'timestamp': 1495994400,
  241.             'upload_date': '20170528',
  242.             'duration': 5283,
  243.             'series': 'GRIP - Das Motormagazin',
  244.             'season_number': 14,
  245.             'episode_number': 405,
  246.             'episode': 'Der neue Porsche 911 GT 3',
  247.         },
  248.     }, {
  249.         # rtl2, episode with season navigation
  250.         'url': 'https://www.tvnow.de/shows/armes-deutschland-11471/staffel-3/episode-14-bernd-steht-seit-der-trennung-von-seiner-frau-allein-da-526124',
  251.         'only_matching': True,
  252.     }, {
  253.         # rtlnitro
  254.         'url': 'https://www.tvnow.de/serien/alarm-fuer-cobra-11-die-autobahnpolizei-1815/staffel-13/episode-5-auf-eigene-faust-pilot-366822',
  255.         'only_matching': True,
  256.     }, {
  257.         # superrtl
  258.         'url': 'https://www.tvnow.de/shows/die-lustigsten-schlamassel-der-welt-1221/staffel-2/episode-14-u-a-ketchup-effekt-364120',
  259.         'only_matching': True,
  260.     }, {
  261.         # ntv
  262.         'url': 'https://www.tvnow.de/shows/startup-news-10674/staffel-2/episode-39-goetter-in-weiss-387630',
  263.         'only_matching': True,
  264.     }, {
  265.         # vox
  266.         'url': 'https://www.tvnow.de/shows/auto-mobil-174/2017-11/episode-46-neues-vom-automobilmarkt-2017-11-19-17-00-00-380072',
  267.         'only_matching': True,
  268.     }, {
  269.         'url': 'https://www.tvnow.de/shows/grip-das-motormagazin-1669/2017-05/episode-405-der-neue-porsche-911-gt-3-331082',
  270.         'only_matching': True,
  271.     }]
  273.     def _extract_video(self, info, url, display_id):
  274.         config = info['config']
  275.         source = config['source']
  277.         video_id = compat_str(info.get('id') or source['videoId'])
  278.         title = source['title'].strip()
  280.         paths = []
  281.         for manifest_url in (info.get('manifest') or {}).values():
  282.             if not manifest_url:
  283.                 continue
  284.             manifest_url = update_url_query(manifest_url, {'filter': ''})
  285.             path = self._search_regex(r'https?://[^/]+/(.+?)\.ism/', manifest_url, 'path')
  286.             if path in paths:
  287.                 continue
  288.             paths.append(path)
  290.             def url_repl(proto, suffix):
  291.                 return re.sub(
  292.                     r'(?:hls|dash|hss)([.-])', proto + r'\1', re.sub(
  293.                         r'\.ism/(?:[^.]*\.(?:m3u8|mpd)|[Mm]anifest)',
  294.                         '.ism/' + suffix, manifest_url))
  296.             formats = self._extract_mpd_formats(
  297.                 url_repl('dash', '.mpd'), video_id,
  298.                 mpd_id='dash', fatal=False)
  299.             formats.extend(self._extract_ism_formats(
  300.                 url_repl('hss', 'Manifest'),
  301.                 video_id, ism_id='mss', fatal=False))
  302.             formats.extend(self._extract_m3u8_formats(
  303.                 url_repl('hls', '.m3u8'), video_id, 'mp4',
  304.                 'm3u8_native', m3u8_id='hls', fatal=False))
  305.             if formats:
  306.                 break
  307.         else:
  308.             if try_get(info, lambda x: x['rights']['isDrm']):
  309.                 raise ExtractorError(
  310.                     'Video %s is DRM protected' % video_id, expected=True)
  311.             if try_get(config, lambda x: x['boards']['geoBlocking']['block']):
  312.                 raise self.raise_geo_restricted()
  313.             if not info.get('free', True):
  314.                 raise ExtractorError(
  315.                     'Video %s is not available for free' % video_id, expected=True)
  316.         self._sort_formats(formats)
  318.         description = source.get('description')
  319.         thumbnail = url_or_none(source.get('poster'))
  320.         timestamp = unified_timestamp(source.get('previewStart'))
  321.         duration = parse_duration(source.get('length'))
  323.         series = source.get('format')
  324.         season_number = int_or_none(self._search_regex(
  325.             r'staffel-(\d+)', url, 'season number', default=None))
  326.         episode_number = int_or_none(self._search_regex(
  327.             r'episode-(\d+)', url, 'episode number', default=None))
  329.         return {
  330.             'id': video_id,
  331.             'display_id': display_id,
  332.             'title': title,
  333.             'description': description,
  334.             'thumbnail': thumbnail,
  335.             'timestamp': timestamp,
  336.             'duration': duration,
  337.             'series': series,
  338.             'season_number': season_number,
  339.             'episode_number': episode_number,
  340.             'episode': title,
  341.             'formats': formats,
  342.         }
  344.     def _real_extract(self, url):
  345.         display_id, video_id = re.match(self._VALID_URL, url).groups()
  346.         info = self._call_api('player/' + video_id, video_id)
  347.         return self._extract_video(info, video_id, display_id)
  348. """
  351. class TVNowListBaseIE(TVNowNewBaseIE):
  352.     _SHOW_VALID_URL = r'''(?x)
  353.                     (?P<base_url>
  354.                         https?://
  355.                             (?:www\.)?tvnow\.(?:de|at|ch)/(?:shows|serien)/
  356.                             [^/?#&]+-(?P<show_id>\d+)
  357.                     )
  358.                     '''
  360.     @classmethod
  361.     def suitable(cls, url):
  362.         return (False if TVNowNewIE.suitable(url)
  363.                 else super(TVNowListBaseIE, cls).suitable(url))
  365.     def _extract_items(self, url, show_id, list_id, query):
  366.         items = self._call_api(
  367.             'teaserrow/format/episode/' + show_id, list_id,
  368.             query=query)['items']
  370.         entries = []
  371.         for item in items:
  372.             if not isinstance(item, dict):
  373.                 continue
  374.             item_url = urljoin(url, item.get('url'))
  375.             if not item_url:
  376.                 continue
  377.             video_id = str_or_none(item.get('id') or item.get('videoId'))
  378.             item_title = item.get('subheadline') or item.get('text')
  379.             entries.append(self.url_result(
  380.                 item_url, ie=TVNowNewIE.ie_key(), video_id=video_id,
  381.                 video_title=item_title))
  383.         return self.playlist_result(entries, '%s/%s' % (show_id, list_id))
  386. class TVNowSeasonIE(TVNowListBaseIE):
  387.     _VALID_URL = r'%s/staffel-(?P<id>\d+)' % TVNowListBaseIE._SHOW_VALID_URL
  388.     _TESTS = [{
  389.         'url': 'https://www.tvnow.de/serien/alarm-fuer-cobra-11-die-autobahnpolizei-1815/staffel-13',
  390.         'info_dict': {
  391.             'id': '1815/13',
  392.         },
  393.         'playlist_mincount': 22,
  394.     }]
  396.     def _real_extract(self, url):
  397.         _, show_id, season_id = re.match(self._VALID_URL, url).groups()
  398.         return self._extract_items(
  399.             url, show_id, season_id, {'season': season_id})
  402. class TVNowAnnualIE(TVNowListBaseIE):
  403.     _VALID_URL = r'%s/(?P<year>\d{4})-(?P<month>\d{2})' % TVNowListBaseIE._SHOW_VALID_URL
  404.     _TESTS = [{
  405.         'url': 'https://www.tvnow.de/shows/grip-das-motormagazin-1669/2017-05',
  406.         'info_dict': {
  407.             'id': '1669/2017-05',
  408.         },
  409.         'playlist_mincount': 2,
  410.     }]
  412.     def _real_extract(self, url):
  413.         _, show_id, year, month = re.match(self._VALID_URL, url).groups()
  414.         return self._extract_items(
  415.             url, show_id, '%s-%s' % (year, month), {
  416.                 'year': int(year),
  417.                 'month': int(month),
  418.             })
  421. class TVNowShowIE(TVNowListBaseIE):
  422.     _VALID_URL = TVNowListBaseIE._SHOW_VALID_URL
  423.     _TESTS = [{
  424.         # annual navigationType
  425.         'url': 'https://www.tvnow.de/shows/grip-das-motormagazin-1669',
  426.         'info_dict': {
  427.             'id': '1669',
  428.         },
  429.         'playlist_mincount': 73,
  430.     }, {
  431.         # season navigationType
  432.         'url': 'https://www.tvnow.de/shows/armes-deutschland-11471',
  433.         'info_dict': {
  434.             'id': '11471',
  435.         },
  436.         'playlist_mincount': 3,
  437.     }]
  439.     @classmethod
  440.     def suitable(cls, url):
  441.         return (False if TVNowNewIE.suitable(url) or TVNowSeasonIE.suitable(url) or TVNowAnnualIE.suitable(url)
  442.                 else super(TVNowShowIE, cls).suitable(url))
  444.     def _real_extract(self, url):
  445.         base_url, show_id = re.match(self._VALID_URL, url).groups()
  447.         result = self._call_api(
  448.             'teaserrow/format/navigation/' + show_id, show_id)
  450.         items = result['items']
  452.         entries = []
  453.         navigation = result.get('navigationType')
  454.         if navigation == 'annual':
  455.             for item in items:
  456.                 if not isinstance(item, dict):
  457.                     continue
  458.                 year = int_or_none(item.get('year'))
  459.                 if year is None:
  460.                     continue
  461.                 months = item.get('months')
  462.                 if not isinstance(months, list):
  463.                     continue
  464.                 for month_dict in months:
  465.                     if not isinstance(month_dict, dict) or not month_dict:
  466.                         continue
  467.                     month_number = int_or_none(list(month_dict.keys())[0])
  468.                     if month_number is None:
  469.                         continue
  470.                     entries.append(self.url_result(
  471.                         '%s/%04d-%02d' % (base_url, year, month_number),
  472.                         ie=TVNowAnnualIE.ie_key()))
  473.         elif navigation == 'season':
  474.             for item in items:
  475.                 if not isinstance(item, dict):
  476.                     continue
  477.                 season_number = int_or_none(item.get('season'))
  478.                 if season_number is None:
  479.                     continue
  480.                 entries.append(self.url_result(
  481.                     '%s/staffel-%d' % (base_url, season_number),
  482.                     ie=TVNowSeasonIE.ie_key()))
  483.         else:
  484.             raise ExtractorError('Unknown navigationType')
  486.         return self.playlist_result(entries, show_id)