[yt-dlp.git] / yt_dlp / extractor / zattoo.py

# coding: utf-8
from __future__ import unicode_literals

import re
from uuid import uuid4

from .common import InfoExtractor
from ..compat import (
    compat_HTTPError,
    compat_str,
)
from ..utils import (
    ExtractorError,
    int_or_none,
    join_nonempty,
    try_get,
    url_or_none,
    urlencode_postdata,
)


class ZattooPlatformBaseIE(InfoExtractor):
    _power_guide_hash = None

    def _host_url(self):
        return 'https://%s' % (self._API_HOST if hasattr(self, '_API_HOST') else self._HOST)

    def _real_initialize(self):
        if not self._power_guide_hash:
            self.raise_login_required('An account is needed to access this media', method='password')

    def _perform_login(self, username, password):
        try:
            data = self._download_json(
                '%s/zapi/v2/account/login' % self._host_url(), None, 'Logging in',
                data=urlencode_postdata({
                    'login': username,
                    'password': password,
                    'remember': 'true',
                }), headers={
                    'Referer': '%s/login' % self._host_url(),
                    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                })
        except ExtractorError as e:
            if isinstance(e.cause, compat_HTTPError) and e.cause.code == 400:
                raise ExtractorError(
                    'Unable to login: incorrect username and/or password',
                    expected=True)
            raise

        self._power_guide_hash = data['session']['power_guide_hash']

    def _initialize_pre_login(self):
        webpage = self._download_webpage(
            self._host_url(), None, 'Downloading app token')
        app_token = self._html_search_regex(
            r'appToken\s*=\s*(["\'])(?P<token>(?:(?!\1).)+?)\1',
            webpage, 'app token', group='token')
        app_version = self._html_search_regex(
            r'<!--\w+-(.+?)-', webpage, 'app version', default='2.8.2')

        # Will setup appropriate cookies
        self._request_webpage(
            '%s/zapi/v2/session/hello' % self._host_url(), None,
            'Opening session', data=urlencode_postdata({
                'client_app_token': app_token,
                'uuid': compat_str(uuid4()),
                'lang': 'en',
                'app_version': app_version,
                'format': 'json',
            }))

    def _extract_cid(self, video_id, channel_name):
        channel_groups = self._download_json(
            '%s/zapi/v2/cached/channels/%s' % (self._host_url(),
                                               self._power_guide_hash),
            video_id, 'Downloading channel list',
            query={'details': False})['channel_groups']
        channel_list = []
        for chgrp in channel_groups:
            channel_list.extend(chgrp['channels'])
        try:
            return next(
                chan['cid'] for chan in channel_list
                if chan.get('cid') and (
                    chan.get('display_alias') == channel_name
                    or chan.get('cid') == channel_name))
        except StopIteration:
            raise ExtractorError('Could not extract channel id')

    def _extract_cid_and_video_info(self, video_id):
        data = self._download_json(
            '%s/zapi/v2/cached/program/power_details/%s' % (
                self._host_url(), self._power_guide_hash),
            video_id,
            'Downloading video information',
            query={
                'program_ids': video_id,
                'complete': True,
            })

        p = data['programs'][0]
        cid = p['cid']

        info_dict = {
            'id': video_id,
            'title': p.get('t') or p['et'],
            'description': p.get('d'),
            'thumbnail': p.get('i_url'),
            'creator': p.get('channel_name'),
            'episode': p.get('et'),
            'episode_number': int_or_none(p.get('e_no')),
            'season_number': int_or_none(p.get('s_no')),
            'release_year': int_or_none(p.get('year')),
            'categories': try_get(p, lambda x: x['c'], list),
            'tags': try_get(p, lambda x: x['g'], list)
        }

        return cid, info_dict

    def _extract_formats(self, cid, video_id, record_id=None, is_live=False):
        postdata_common = {
            'https_watch_urls': True,
        }

        if is_live:
            postdata_common.update({'timeshift': 10800})
            url = '%s/zapi/watch/live/%s' % (self._host_url(), cid)
        elif record_id:
            url = '%s/zapi/watch/recording/%s' % (self._host_url(), record_id)
        else:
            url = '%s/zapi/watch/recall/%s/%s' % (self._host_url(), cid, video_id)

        formats = []
        for stream_type in ('dash', 'hls', 'hls5', 'hds'):
            postdata = postdata_common.copy()
            postdata['stream_type'] = stream_type

            data = self._download_json(
                url, video_id, 'Downloading %s formats' % stream_type.upper(),
                data=urlencode_postdata(postdata), fatal=False)
            if not data:
                continue

            watch_urls = try_get(
                data, lambda x: x['stream']['watch_urls'], list)
            if not watch_urls:
                continue

            for watch in watch_urls:
                if not isinstance(watch, dict):
                    continue
                watch_url = url_or_none(watch.get('url'))
                if not watch_url:
                    continue
                audio_channel = watch.get('audio_channel')
                preference = 1 if audio_channel == 'A' else None
                format_id = join_nonempty(stream_type, watch.get('maxrate'), audio_channel)
                if stream_type in ('dash', 'dash_widevine', 'dash_playready'):
                    this_formats = self._extract_mpd_formats(
                        watch_url, video_id, mpd_id=format_id, fatal=False)
                elif stream_type in ('hls', 'hls5', 'hls5_fairplay'):
                    this_formats = self._extract_m3u8_formats(
                        watch_url, video_id, 'mp4',
                        entry_protocol='m3u8_native', m3u8_id=format_id,
                        fatal=False)
                elif stream_type == 'hds':
                    this_formats = self._extract_f4m_formats(
                        watch_url, video_id, f4m_id=format_id, fatal=False)
                elif stream_type == 'smooth_playready':
                    this_formats = self._extract_ism_formats(
                        watch_url, video_id, ism_id=format_id, fatal=False)
                else:
                    assert False
                for this_format in this_formats:
                    this_format['quality'] = preference
                formats.extend(this_formats)
        self._sort_formats(formats)
        return formats

    def _extract_video(self, channel_name, video_id, record_id=None, is_live=False):
        if is_live:
            cid = self._extract_cid(video_id, channel_name)
            info_dict = {
                'id': channel_name,
                'title': channel_name,
                'is_live': True,
            }
        else:
            cid, info_dict = self._extract_cid_and_video_info(video_id)
        formats = self._extract_formats(
            cid, video_id, record_id=record_id, is_live=is_live)
        info_dict['formats'] = formats
        return info_dict


class QuicklineBaseIE(ZattooPlatformBaseIE):
    _NETRC_MACHINE = 'quickline'
    _HOST = 'mobiltv.quickline.com'


class QuicklineIE(QuicklineBaseIE):
    _VALID_URL = r'https?://(?:www\.)?%s/watch/(?P<channel>[^/]+)/(?P<id>[0-9]+)' % re.escape(QuicklineBaseIE._HOST)

    _TEST = {
        'url': 'https://mobiltv.quickline.com/watch/prosieben/130671867-maze-runner-die-auserwaehlten-in-der-brandwueste',
        'only_matching': True,
    }

    def _real_extract(self, url):
        channel_name, video_id = self._match_valid_url(url).groups()
        return self._extract_video(channel_name, video_id)


class QuicklineLiveIE(QuicklineBaseIE):
    _VALID_URL = r'https?://(?:www\.)?%s/watch/(?P<id>[^/]+)' % re.escape(QuicklineBaseIE._HOST)

    _TEST = {
        'url': 'https://mobiltv.quickline.com/watch/srf1',
        'only_matching': True,
    }

    @classmethod
    def suitable(cls, url):
        return False if QuicklineIE.suitable(url) else super(QuicklineLiveIE, cls).suitable(url)

    def _real_extract(self, url):
        channel_name = video_id = self._match_id(url)
        return self._extract_video(channel_name, video_id, is_live=True)


class ZattooBaseIE(ZattooPlatformBaseIE):
    _NETRC_MACHINE = 'zattoo'
    _HOST = 'zattoo.com'


def _make_valid_url(tmpl, host):
    return tmpl % re.escape(host)


class ZattooIE(ZattooBaseIE):
    _VALID_URL_TEMPLATE = r'https?://(?:www\.)?%s/watch/(?P<channel>[^/]+?)/(?P<id>[0-9]+)[^/]+(?:/(?P<recid>[0-9]+))?'
    _VALID_URL = _make_valid_url(_VALID_URL_TEMPLATE, ZattooBaseIE._HOST)

    # Since regular videos are only available for 7 days and recorded videos
    # are only available for a specific user, we cannot have detailed tests.
    _TESTS = [{
        'url': 'https://zattoo.com/watch/prosieben/130671867-maze-runner-die-auserwaehlten-in-der-brandwueste',
        'only_matching': True,
    }, {
        'url': 'https://zattoo.com/watch/srf_zwei/132905652-eishockey-spengler-cup/102791477/1512211800000/1514433500000/92000',
        'only_matching': True,
    }]

    def _real_extract(self, url):
        channel_name, video_id, record_id = self._match_valid_url(url).groups()
        return self._extract_video(channel_name, video_id, record_id)


class ZattooLiveIE(ZattooBaseIE):
    _VALID_URL = r'https?://(?:www\.)?zattoo\.com/watch/(?P<id>[^/]+)'

    _TEST = {
        'url': 'https://zattoo.com/watch/srf1',
        'only_matching': True,
    }

    @classmethod
    def suitable(cls, url):
        return False if ZattooIE.suitable(url) else super(ZattooLiveIE, cls).suitable(url)

    def _real_extract(self, url):
        channel_name = video_id = self._match_id(url)
        return self._extract_video(channel_name, video_id, is_live=True)


class NetPlusIE(ZattooIE):
    _NETRC_MACHINE = 'netplus'
    _HOST = 'netplus.tv'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.netplus.tv/watch/abc/123-abc',
        'only_matching': True,
    }]


class MNetTVIE(ZattooIE):
    _NETRC_MACHINE = 'mnettv'
    _HOST = 'tvplus.m-net.de'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://tvplus.m-net.de/watch/abc/123-abc',
        'only_matching': True,
    }]


class WalyTVIE(ZattooIE):
    _NETRC_MACHINE = 'walytv'
    _HOST = 'player.waly.tv'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://player.waly.tv/watch/abc/123-abc',
        'only_matching': True,
    }]


class BBVTVIE(ZattooIE):
    _NETRC_MACHINE = 'bbvtv'
    _HOST = 'bbv-tv.net'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.bbv-tv.net/watch/abc/123-abc',
        'only_matching': True,
    }]


class VTXTVIE(ZattooIE):
    _NETRC_MACHINE = 'vtxtv'
    _HOST = 'vtxtv.ch'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.vtxtv.ch/watch/abc/123-abc',
        'only_matching': True,
    }]


class MyVisionTVIE(ZattooIE):
    _NETRC_MACHINE = 'myvisiontv'
    _HOST = 'myvisiontv.ch'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.myvisiontv.ch/watch/abc/123-abc',
        'only_matching': True,
    }]


class GlattvisionTVIE(ZattooIE):
    _NETRC_MACHINE = 'glattvisiontv'
    _HOST = 'iptv.glattvision.ch'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://iptv.glattvision.ch/watch/abc/123-abc',
        'only_matching': True,
    }]


class SAKTVIE(ZattooIE):
    _NETRC_MACHINE = 'saktv'
    _HOST = 'saktv.ch'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.saktv.ch/watch/abc/123-abc',
        'only_matching': True,
    }]


class EWETVIE(ZattooIE):
    _NETRC_MACHINE = 'ewetv'
    _HOST = 'tvonline.ewe.de'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://tvonline.ewe.de/watch/abc/123-abc',
        'only_matching': True,
    }]


class QuantumTVIE(ZattooIE):
    _NETRC_MACHINE = 'quantumtv'
    _HOST = 'quantum-tv.com'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.quantum-tv.com/watch/abc/123-abc',
        'only_matching': True,
    }]


class OsnatelTVIE(ZattooIE):
    _NETRC_MACHINE = 'osnateltv'
    _HOST = 'tvonline.osnatel.de'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://tvonline.osnatel.de/watch/abc/123-abc',
        'only_matching': True,
    }]


class EinsUndEinsTVIE(ZattooIE):
    _NETRC_MACHINE = '1und1tv'
    _HOST = '1und1.tv'
    _API_HOST = 'www.%s' % _HOST
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://www.1und1.tv/watch/abc/123-abc',
        'only_matching': True,
    }]


class SaltTVIE(ZattooIE):
    _NETRC_MACHINE = 'salttv'
    _HOST = 'tv.salt.ch'
    _VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)

    _TESTS = [{
        'url': 'https://tv.salt.ch/watch/abc/123-abc',
        'only_matching': True,
    }]
Commit	Line	Data
4a733545 AS	1	# coding: utf-8
	2	from __future__ import unicode_literals
	3
4a733545	4	import re
67ca1a8e	5	from uuid import uuid4
4a733545 AS	6
4a733545 AS	7	from .common import InfoExtractor
67ca1a8e S	8	from ..compat import (
67ca1a8e S	9	compat_HTTPError,
4a733545	10	compat_str,
67ca1a8e S	11	)
67ca1a8e S	12	from ..utils import (
4a733545	13	ExtractorError,
67ca1a8e	14	int_or_none,
34921b43	15	join_nonempty,
67ca1a8e	16	try_get,
3052a30d	17	url_or_none,
4a733545 AS	18	urlencode_postdata,
	19	)
	20
	21
f6d7f7b4	22	class ZattooPlatformBaseIE(InfoExtractor):
4a733545 AS	23	_power_guide_hash = None
4a733545 AS	24
f6d7f7b4	25	def _host_url(self):
16d896b2	26	return 'https://%s' % (self._API_HOST if hasattr(self, '_API_HOST') else self._HOST)
f6d7f7b4	27
52efa4b3	28	def _real_initialize(self):
	29	if not self._power_guide_hash:
	30	self.raise_login_required('An account is needed to access this media', method='password')
67ca1a8e	31
52efa4b3	32	def _perform_login(self, username, password):
67ca1a8e S	33	try:
67ca1a8e S	34	data = self._download_json(
f6d7f7b4	35	'%s/zapi/v2/account/login' % self._host_url(), None, 'Logging in',
67ca1a8e S	36	data=urlencode_postdata({
	37	'login': username,
	38	'password': password,
	39	'remember': 'true',
	40	}), headers={
f6d7f7b4	41	'Referer': '%s/login' % self._host_url(),
67ca1a8e S	42	'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
	43	})
	44	except ExtractorError as e:
	45	if isinstance(e.cause, compat_HTTPError) and e.cause.code == 400:
	46	raise ExtractorError(
	47	'Unable to login: incorrect username and/or password',
	48	expected=True)
	49	raise
	50
	51	self._power_guide_hash = data['session']['power_guide_hash']
	52
52efa4b3	53	def _initialize_pre_login(self):
67ca1a8e	54	webpage = self._download_webpage(
f6d7f7b4	55	self._host_url(), None, 'Downloading app token')
4a733545	56	app_token = self._html_search_regex(
67ca1a8e S	57	r'appToken\s=\s(["\'])(?P<token>(?:(?!\1).)+?)\1',
67ca1a8e S	58	webpage, 'app token', group='token')
4a733545	59	app_version = self._html_search_regex(
67ca1a8e S	60	r'<!--\w+-(.+?)-', webpage, 'app version', default='2.8.2')
	61
	62	# Will setup appropriate cookies
	63	self._request_webpage(
f6d7f7b4	64	'%s/zapi/v2/session/hello' % self._host_url(), None,
67ca1a8e S	65	'Opening session', data=urlencode_postdata({
	66	'client_app_token': app_token,
	67	'uuid': compat_str(uuid4()),
	68	'lang': 'en',
	69	'app_version': app_version,
	70	'format': 'json',
	71	}))
4a733545	72
4a733545 AS	73	def _extract_cid(self, video_id, channel_name):
4a733545 AS	74	channel_groups = self._download_json(
f6d7f7b4	75	'%s/zapi/v2/cached/channels/%s' % (self._host_url(),
4a733545	76	self._power_guide_hash),
67ca1a8e	77	video_id, 'Downloading channel list',
4a733545 AS	78	query={'details': False})['channel_groups']
	79	channel_list = []
	80	for chgrp in channel_groups:
	81	channel_list.extend(chgrp['channels'])
	82	try:
	83	return next(
	84	chan['cid'] for chan in channel_list
67ca1a8e	85	if chan.get('cid') and (
3089bc74 S	86	chan.get('display_alias') == channel_name
3089bc74 S	87	or chan.get('cid') == channel_name))
4a733545 AS	88	except StopIteration:
	89	raise ExtractorError('Could not extract channel id')
	90
	91	def _extract_cid_and_video_info(self, video_id):
	92	data = self._download_json(
21160a17	93	'%s/zapi/v2/cached/program/power_details/%s' % (
f6d7f7b4	94	self._host_url(), self._power_guide_hash),
4a733545 AS	95	video_id,
	96	'Downloading video information',
	97	query={
21160a17 AS	98	'program_ids': video_id,
21160a17 AS	99	'complete': True,
4a733545 AS	100	})
4a733545 AS	101
21160a17	102	p = data['programs'][0]
67ca1a8e S	103	cid = p['cid']
67ca1a8e S	104
4a733545 AS	105	info_dict = {
4a733545 AS	106	'id': video_id,
21160a17 AS	107	'title': p.get('t') or p['et'],
	108	'description': p.get('d'),
	109	'thumbnail': p.get('i_url'),
67ca1a8e	110	'creator': p.get('channel_name'),
21160a17 AS	111	'episode': p.get('et'),
	112	'episode_number': int_or_none(p.get('e_no')),
	113	'season_number': int_or_none(p.get('s_no')),
67ca1a8e	114	'release_year': int_or_none(p.get('year')),
21160a17 AS	115	'categories': try_get(p, lambda x: x['c'], list),
21160a17 AS	116	'tags': try_get(p, lambda x: x['g'], list)
4a733545	117	}
67ca1a8e	118
4a733545 AS	119	return cid, info_dict
	120
	121	def _extract_formats(self, cid, video_id, record_id=None, is_live=False):
67ca1a8e	122	postdata_common = {
4a733545 AS	123	'https_watch_urls': True,
4a733545 AS	124	}
4a733545 AS	125
4a733545 AS	126	if is_live:
67ca1a8e	127	postdata_common.update({'timeshift': 10800})
f6d7f7b4	128	url = '%s/zapi/watch/live/%s' % (self._host_url(), cid)
67ca1a8e	129	elif record_id:
f6d7f7b4	130	url = '%s/zapi/watch/recording/%s' % (self._host_url(), record_id)
67ca1a8e	131	else:
f6d7f7b4	132	url = '%s/zapi/watch/recall/%s/%s' % (self._host_url(), cid, video_id)
4a733545 AS	133
4a733545 AS	134	formats = []
67ca1a8e S	135	for stream_type in ('dash', 'hls', 'hls5', 'hds'):
	136	postdata = postdata_common.copy()
	137	postdata['stream_type'] = stream_type
	138
	139	data = self._download_json(
	140	url, video_id, 'Downloading %s formats' % stream_type.upper(),
	141	data=urlencode_postdata(postdata), fatal=False)
	142	if not data:
	143	continue
	144
	145	watch_urls = try_get(
	146	data, lambda x: x['stream']['watch_urls'], list)
	147	if not watch_urls:
	148	continue
	149
	150	for watch in watch_urls:
	151	if not isinstance(watch, dict):
	152	continue
3052a30d S	153	watch_url = url_or_none(watch.get('url'))
3052a30d S	154	if not watch_url:
67ca1a8e	155	continue
67ca1a8e	156	audio_channel = watch.get('audio_channel')
67ca1a8e	157	preference = 1 if audio_channel == 'A' else None
34921b43	158	format_id = join_nonempty(stream_type, watch.get('maxrate'), audio_channel)
67ca1a8e S	159	if stream_type in ('dash', 'dash_widevine', 'dash_playready'):
	160	this_formats = self._extract_mpd_formats(
	161	watch_url, video_id, mpd_id=format_id, fatal=False)
	162	elif stream_type in ('hls', 'hls5', 'hls5_fairplay'):
	163	this_formats = self._extract_m3u8_formats(
	164	watch_url, video_id, 'mp4',
	165	entry_protocol='m3u8_native', m3u8_id=format_id,
	166	fatal=False)
	167	elif stream_type == 'hds':
	168	this_formats = self._extract_f4m_formats(
	169	watch_url, video_id, f4m_id=format_id, fatal=False)
	170	elif stream_type == 'smooth_playready':
	171	this_formats = self._extract_ism_formats(
	172	watch_url, video_id, ism_id=format_id, fatal=False)
	173	else:
	174	assert False
	175	for this_format in this_formats:
f983b875	176	this_format['quality'] = preference
67ca1a8e	177	formats.extend(this_formats)
4a733545 AS	178	self._sort_formats(formats)
	179	return formats
	180
4a733545 AS	181	def _extract_video(self, channel_name, video_id, record_id=None, is_live=False):
	182	if is_live:
	183	cid = self._extract_cid(video_id, channel_name)
	184	info_dict = {
	185	'id': channel_name,
39ca3b5c	186	'title': channel_name,
4a733545 AS	187	'is_live': True,
	188	}
	189	else:
	190	cid, info_dict = self._extract_cid_and_video_info(video_id)
	191	formats = self._extract_formats(
	192	cid, video_id, record_id=record_id, is_live=is_live)
	193	info_dict['formats'] = formats
	194	return info_dict
	195
	196
f6d7f7b4	197	class QuicklineBaseIE(ZattooPlatformBaseIE):
4a733545	198	_NETRC_MACHINE = 'quickline'
f6d7f7b4	199	_HOST = 'mobiltv.quickline.com'
4a733545 AS	200
	201
	202	class QuicklineIE(QuicklineBaseIE):
f6d7f7b4	203	_VALID_URL = r'https?://(?:www\.)?%s/watch/(?P<channel>[^/]+)/(?P<id>[0-9]+)' % re.escape(QuicklineBaseIE._HOST)
4a733545	204
67ca1a8e S	205	_TEST = {
	206	'url': 'https://mobiltv.quickline.com/watch/prosieben/130671867-maze-runner-die-auserwaehlten-in-der-brandwueste',
	207	'only_matching': True,
	208	}
	209
4a733545	210	def _real_extract(self, url):
5ad28e7f	211	channel_name, video_id = self._match_valid_url(url).groups()
4a733545 AS	212	return self._extract_video(channel_name, video_id)
	213
	214
	215	class QuicklineLiveIE(QuicklineBaseIE):
f6d7f7b4	216	_VALID_URL = r'https?://(?:www\.)?%s/watch/(?P<id>[^/]+)' % re.escape(QuicklineBaseIE._HOST)
67ca1a8e S	217
	218	_TEST = {
	219	'url': 'https://mobiltv.quickline.com/watch/srf1',
	220	'only_matching': True,
	221	}
	222
	223	@classmethod
	224	def suitable(cls, url):
	225	return False if QuicklineIE.suitable(url) else super(QuicklineLiveIE, cls).suitable(url)
4a733545 AS	226
	227	def _real_extract(self, url):
	228	channel_name = video_id = self._match_id(url)
	229	return self._extract_video(channel_name, video_id, is_live=True)
	230
	231
f6d7f7b4 S	232	class ZattooBaseIE(ZattooPlatformBaseIE):
	233	_NETRC_MACHINE = 'zattoo'
	234	_HOST = 'zattoo.com'
	235
	236
	237	def _make_valid_url(tmpl, host):
	238	return tmpl % re.escape(host)
	239
	240
4a733545	241	class ZattooIE(ZattooBaseIE):
f6d7f7b4 S	242	_VALID_URL_TEMPLATE = r'https?://(?:www\.)?%s/watch/(?P<channel>[^/]+?)/(?P<id>[0-9]+)[^/]+(?:/(?P<recid>[0-9]+))?'
f6d7f7b4 S	243	_VALID_URL = _make_valid_url(_VALID_URL_TEMPLATE, ZattooBaseIE._HOST)
4a733545 AS	244
	245	# Since regular videos are only available for 7 days and recorded videos
	246	# are only available for a specific user, we cannot have detailed tests.
	247	_TESTS = [{
	248	'url': 'https://zattoo.com/watch/prosieben/130671867-maze-runner-die-auserwaehlten-in-der-brandwueste',
	249	'only_matching': True,
	250	}, {
	251	'url': 'https://zattoo.com/watch/srf_zwei/132905652-eishockey-spengler-cup/102791477/1512211800000/1514433500000/92000',
	252	'only_matching': True,
	253	}]
	254
	255	def _real_extract(self, url):
5ad28e7f	256	channel_name, video_id, record_id = self._match_valid_url(url).groups()
4a733545 AS	257	return self._extract_video(channel_name, video_id, record_id)
	258
	259
	260	class ZattooLiveIE(ZattooBaseIE):
67ca1a8e	261	_VALID_URL = r'https?://(?:www\.)?zattoo\.com/watch/(?P<id>[^/]+)'
4a733545 AS	262
	263	_TEST = {
	264	'url': 'https://zattoo.com/watch/srf1',
	265	'only_matching': True,
	266	}
	267
67ca1a8e S	268	@classmethod
	269	def suitable(cls, url):
	270	return False if ZattooIE.suitable(url) else super(ZattooLiveIE, cls).suitable(url)
	271
4a733545 AS	272	def _real_extract(self, url):
	273	channel_name = video_id = self._match_id(url)
	274	return self._extract_video(channel_name, video_id, is_live=True)
f6d7f7b4 S	275
	276
	277	class NetPlusIE(ZattooIE):
	278	_NETRC_MACHINE = 'netplus'
	279	_HOST = 'netplus.tv'
16d896b2	280	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	281	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	282
	283	_TESTS = [{
	284	'url': 'https://www.netplus.tv/watch/abc/123-abc',
	285	'only_matching': True,
	286	}]
	287
	288
	289	class MNetTVIE(ZattooIE):
	290	_NETRC_MACHINE = 'mnettv'
	291	_HOST = 'tvplus.m-net.de'
	292	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	293
	294	_TESTS = [{
16d896b2	295	'url': 'https://tvplus.m-net.de/watch/abc/123-abc',
f6d7f7b4 S	296	'only_matching': True,
	297	}]
	298
	299
	300	class WalyTVIE(ZattooIE):
	301	_NETRC_MACHINE = 'walytv'
	302	_HOST = 'player.waly.tv'
	303	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	304
	305	_TESTS = [{
16d896b2	306	'url': 'https://player.waly.tv/watch/abc/123-abc',
f6d7f7b4 S	307	'only_matching': True,
	308	}]
	309
	310
	311	class BBVTVIE(ZattooIE):
	312	_NETRC_MACHINE = 'bbvtv'
	313	_HOST = 'bbv-tv.net'
16d896b2	314	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	315	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	316
	317	_TESTS = [{
	318	'url': 'https://www.bbv-tv.net/watch/abc/123-abc',
	319	'only_matching': True,
	320	}]
	321
	322
	323	class VTXTVIE(ZattooIE):
	324	_NETRC_MACHINE = 'vtxtv'
	325	_HOST = 'vtxtv.ch'
16d896b2	326	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	327	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	328
	329	_TESTS = [{
	330	'url': 'https://www.vtxtv.ch/watch/abc/123-abc',
	331	'only_matching': True,
	332	}]
	333
	334
	335	class MyVisionTVIE(ZattooIE):
	336	_NETRC_MACHINE = 'myvisiontv'
	337	_HOST = 'myvisiontv.ch'
16d896b2	338	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	339	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	340
	341	_TESTS = [{
	342	'url': 'https://www.myvisiontv.ch/watch/abc/123-abc',
	343	'only_matching': True,
	344	}]
	345
	346
	347	class GlattvisionTVIE(ZattooIE):
	348	_NETRC_MACHINE = 'glattvisiontv'
	349	_HOST = 'iptv.glattvision.ch'
	350	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	351
	352	_TESTS = [{
16d896b2	353	'url': 'https://iptv.glattvision.ch/watch/abc/123-abc',
f6d7f7b4 S	354	'only_matching': True,
	355	}]
	356
	357
	358	class SAKTVIE(ZattooIE):
	359	_NETRC_MACHINE = 'saktv'
	360	_HOST = 'saktv.ch'
16d896b2	361	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	362	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	363
	364	_TESTS = [{
	365	'url': 'https://www.saktv.ch/watch/abc/123-abc',
	366	'only_matching': True,
	367	}]
	368
	369
	370	class EWETVIE(ZattooIE):
	371	_NETRC_MACHINE = 'ewetv'
	372	_HOST = 'tvonline.ewe.de'
	373	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	374
	375	_TESTS = [{
16d896b2	376	'url': 'https://tvonline.ewe.de/watch/abc/123-abc',
f6d7f7b4 S	377	'only_matching': True,
	378	}]
	379
	380
	381	class QuantumTVIE(ZattooIE):
	382	_NETRC_MACHINE = 'quantumtv'
	383	_HOST = 'quantum-tv.com'
16d896b2	384	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	385	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	386
	387	_TESTS = [{
	388	'url': 'https://www.quantum-tv.com/watch/abc/123-abc',
	389	'only_matching': True,
	390	}]
	391
	392
	393	class OsnatelTVIE(ZattooIE):
	394	_NETRC_MACHINE = 'osnateltv'
2004e221	395	_HOST = 'tvonline.osnatel.de'
f6d7f7b4 S	396	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	397
	398	_TESTS = [{
16d896b2	399	'url': 'https://tvonline.osnatel.de/watch/abc/123-abc',
f6d7f7b4 S	400	'only_matching': True,
	401	}]
	402
	403
	404	class EinsUndEinsTVIE(ZattooIE):
	405	_NETRC_MACHINE = '1und1tv'
	406	_HOST = '1und1.tv'
16d896b2	407	_API_HOST = 'www.%s' % _HOST
f6d7f7b4 S	408	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	409
	410	_TESTS = [{
	411	'url': 'https://www.1und1.tv/watch/abc/123-abc',
	412	'only_matching': True,
	413	}]
a81daba2 AS	414
	415
	416	class SaltTVIE(ZattooIE):
	417	_NETRC_MACHINE = 'salttv'
	418	_HOST = 'tv.salt.ch'
	419	_VALID_URL = _make_valid_url(ZattooIE._VALID_URL_TEMPLATE, _HOST)
	420
	421	_TESTS = [{
	422	'url': 'https://tv.salt.ch/watch/abc/123-abc',
	423	'only_matching': True,
	424	}]