404

[ Avaa Bypassed ]




Upload:

Command:

botdev@3.141.46.77: ~ $
# coding: utf-8
from __future__ import unicode_literals

import base64
import functools
import json
import re
import itertools

from .common import InfoExtractor
from ..compat import (
    compat_kwargs,
    compat_HTTPError,
    compat_str,
    compat_urlparse,
)
from ..utils import (
    clean_html,
    determine_ext,
    dict_get,
    ExtractorError,
    js_to_json,
    int_or_none,
    merge_dicts,
    OnDemandPagedList,
    parse_filesize,
    RegexNotFoundError,
    sanitized_Request,
    smuggle_url,
    std_headers,
    str_or_none,
    try_get,
    unified_timestamp,
    unsmuggle_url,
    urlencode_postdata,
    urljoin,
    unescapeHTML,
)


class VimeoBaseInfoExtractor(InfoExtractor):
    _NETRC_MACHINE = 'vimeo'
    _LOGIN_REQUIRED = False
    _LOGIN_URL = 'https://vimeo.com/log_in'

    def _login(self):
        username, password = self._get_login_info()
        if username is None:
            if self._LOGIN_REQUIRED:
                raise ExtractorError('No login info available, needed for using %s.' % self.IE_NAME, expected=True)
            return
        webpage = self._download_webpage(
            self._LOGIN_URL, None, 'Downloading login page')
        token, vuid = self._extract_xsrft_and_vuid(webpage)
        data = {
            'action': 'login',
            'email': username,
            'password': password,
            'service': 'vimeo',
            'token': token,
        }
        self._set_vimeo_cookie('vuid', vuid)
        try:
            self._download_webpage(
                self._LOGIN_URL, None, 'Logging in',
                data=urlencode_postdata(data), headers={
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Referer': self._LOGIN_URL,
                })
        except ExtractorError as e:
            if isinstance(e.cause, compat_HTTPError) and e.cause.code == 418:
                raise ExtractorError(
                    'Unable to log in: bad username or password',
                    expected=True)
            raise ExtractorError('Unable to log in')

    def _verify_video_password(self, url, video_id, webpage):
        password = self._downloader.params.get('videopassword')
        if password is None:
            raise ExtractorError('This video is protected by a password, use the --video-password option', expected=True)
        token, vuid = self._extract_xsrft_and_vuid(webpage)
        data = urlencode_postdata({
            'password': password,
            'token': token,
        })
        if url.startswith('http://'):
            # vimeo only supports https now, but the user can give an http url
            url = url.replace('http://', 'https://')
        password_request = sanitized_Request(url + '/password', data)
        password_request.add_header('Content-Type', 'application/x-www-form-urlencoded')
        password_request.add_header('Referer', url)
        self._set_vimeo_cookie('vuid', vuid)
        return self._download_webpage(
            password_request, video_id,
            'Verifying the password', 'Wrong password')

    def _extract_xsrft_and_vuid(self, webpage):
        xsrft = self._search_regex(
            r'(?:(?P<q1>["\'])xsrft(?P=q1)\s*:|xsrft\s*[=:])\s*(?P<q>["\'])(?P<xsrft>.+?)(?P=q)',
            webpage, 'login token', group='xsrft')
        vuid = self._search_regex(
            r'["\']vuid["\']\s*:\s*(["\'])(?P<vuid>.+?)\1',
            webpage, 'vuid', group='vuid')
        return xsrft, vuid

    def _extract_vimeo_config(self, webpage, video_id, *args, **kwargs):
        vimeo_config = self._search_regex(
            r'vimeo\.config\s*=\s*(?:({.+?})|_extend\([^,]+,\s+({.+?})\));',
            webpage, 'vimeo config', *args, **compat_kwargs(kwargs))
        if vimeo_config:
            return self._parse_json(vimeo_config, video_id)

    def _set_vimeo_cookie(self, name, value):
        self._set_cookie('vimeo.com', name, value)

    def _vimeo_sort_formats(self, formats):
        # Bitrates are completely broken. Single m3u8 may contain entries in kbps and bps
        # at the same time without actual units specified. This lead to wrong sorting.
        self._sort_formats(formats, field_preference=('preference', 'height', 'width', 'fps', 'tbr', 'format_id'))

    def _parse_config(self, config, video_id):
        video_data = config['video']
        video_title = video_data['title']
        live_event = video_data.get('live_event') or {}
        is_live = live_event.get('status') == 'started'

        formats = []
        config_files = video_data.get('files') or config['request'].get('files', {})
        for f in config_files.get('progressive', []):
            video_url = f.get('url')
            if not video_url:
                continue
            formats.append({
                'url': video_url,
                'format_id': 'http-%s' % f.get('quality'),
                'width': int_or_none(f.get('width')),
                'height': int_or_none(f.get('height')),
                'fps': int_or_none(f.get('fps')),
                'tbr': int_or_none(f.get('bitrate')),
            })

        # TODO: fix handling of 308 status code returned for live archive manifest requests
        sep_pattern = r'/sep/video/'
        for files_type in ('hls', 'dash'):
            for cdn_name, cdn_data in config_files.get(files_type, {}).get('cdns', {}).items():
                manifest_url = cdn_data.get('url')
                if not manifest_url:
                    continue
                format_id = '%s-%s' % (files_type, cdn_name)
                sep_manifest_urls = []
                if re.search(sep_pattern, manifest_url):
                    for suffix, repl in (('', 'video'), ('_sep', 'sep/video')):
                        sep_manifest_urls.append((format_id + suffix, re.sub(
                            sep_pattern, '/%s/' % repl, manifest_url)))
                else:
                    sep_manifest_urls = [(format_id, manifest_url)]
                for f_id, m_url in sep_manifest_urls:
                    if files_type == 'hls':
                        formats.extend(self._extract_m3u8_formats(
                            m_url, video_id, 'mp4',
                            'm3u8' if is_live else 'm3u8_native', m3u8_id=f_id,
                            note='Downloading %s m3u8 information' % cdn_name,
                            fatal=False))
                    elif files_type == 'dash':
                        if 'json=1' in m_url:
                            real_m_url = (self._download_json(m_url, video_id, fatal=False) or {}).get('url')
                            if real_m_url:
                                m_url = real_m_url
                        mpd_formats = self._extract_mpd_formats(
                            m_url.replace('/master.json', '/master.mpd'), video_id, f_id,
                            'Downloading %s MPD information' % cdn_name,
                            fatal=False)
                        formats.extend(mpd_formats)

        live_archive = live_event.get('archive') or {}
        live_archive_source_url = live_archive.get('source_url')
        if live_archive_source_url and live_archive.get('status') == 'done':
            formats.append({
                'format_id': 'live-archive-source',
                'url': live_archive_source_url,
                'preference': 1,
            })

        for f in formats:
            if f.get('vcodec') == 'none':
                f['preference'] = -50
            elif f.get('acodec') == 'none':
                f['preference'] = -40

        subtitles = {}
        text_tracks = config['request'].get('text_tracks')
        if text_tracks:
            for tt in text_tracks:
                subtitles[tt['lang']] = [{
                    'ext': 'vtt',
                    'url': urljoin('https://vimeo.com', tt['url']),
                }]

        thumbnails = []
        if not is_live:
            for key, thumb in video_data.get('thumbs', {}).items():
                thumbnails.append({
                    'id': key,
                    'width': int_or_none(key),
                    'url': thumb,
                })
            thumbnail = video_data.get('thumbnail')
            if thumbnail:
                thumbnails.append({
                    'url': thumbnail,
                })

        owner = video_data.get('owner') or {}
        video_uploader_url = owner.get('url')

        return {
            'id': str_or_none(video_data.get('id')) or video_id,
            'title': self._live_title(video_title) if is_live else video_title,
            'uploader': owner.get('name'),
            'uploader_id': video_uploader_url.split('/')[-1] if video_uploader_url else None,
            'uploader_url': video_uploader_url,
            'thumbnails': thumbnails,
            'duration': int_or_none(video_data.get('duration')),
            'formats': formats,
            'subtitles': subtitles,
            'is_live': is_live,
        }

    def _extract_original_format(self, url, video_id):
        download_data = self._download_json(
            url, video_id, fatal=False,
            query={'action': 'load_download_config'},
            headers={'X-Requested-With': 'XMLHttpRequest'})
        if download_data:
            source_file = download_data.get('source_file')
            if isinstance(source_file, dict):
                download_url = source_file.get('download_url')
                if download_url and not source_file.get('is_cold') and not source_file.get('is_defrosting'):
                    source_name = source_file.get('public_name', 'Original')
                    if self._is_valid_url(download_url, video_id, '%s video' % source_name):
                        ext = (try_get(
                            source_file, lambda x: x['extension'],
                            compat_str) or determine_ext(
                            download_url, None) or 'mp4').lower()
                        return {
                            'url': download_url,
                            'ext': ext,
                            'width': int_or_none(source_file.get('width')),
                            'height': int_or_none(source_file.get('height')),
                            'filesize': parse_filesize(source_file.get('size')),
                            'format_id': source_name,
                            'preference': 1,
                        }


class VimeoIE(VimeoBaseInfoExtractor):
    """Information extractor for vimeo.com."""

    # _VALID_URL matches Vimeo URLs
    _VALID_URL = r'''(?x)
                    https?://
                        (?:
                            (?:
                                www|
                                player
                            )
                            \.
                        )?
                        vimeo(?:pro)?\.com/
                        (?!(?:channels|album|showcase)/[^/?#]+/?(?:$|[?#])|[^/]+/review/|ondemand/)
                        (?:.*?/)?
                        (?:
                            (?:
                                play_redirect_hls|
                                moogaloop\.swf)\?clip_id=
                            )?
                        (?:videos?/)?
                        (?P<id>[0-9]+)
                        (?:/[\da-f]+)?
                        /?(?:[?&].*)?(?:[#].*)?$
                    '''
    IE_NAME = 'vimeo'
    _TESTS = [
        {
            'url': 'http://vimeo.com/56015672#at=0',
            'md5': '8879b6cc097e987f02484baf890129e5',
            'info_dict': {
                'id': '56015672',
                'ext': 'mp4',
                'title': "youtube-dl test video - \u2605 \" ' \u5e78 / \\ \u00e4 \u21ad \U0001d550",
                'description': 'md5:2d3305bad981a06ff79f027f19865021',
                'timestamp': 1355990239,
                'upload_date': '20121220',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/user7108434',
                'uploader_id': 'user7108434',
                'uploader': 'Filippo Valsorda',
                'duration': 10,
                'license': 'by-sa',
            },
            'params': {
                'format': 'best[protocol=https]',
            },
        },
        {
            'url': 'http://vimeopro.com/openstreetmapus/state-of-the-map-us-2013/video/68093876',
            'md5': '3b5ca6aa22b60dfeeadf50b72e44ed82',
            'note': 'Vimeo Pro video (#1197)',
            'info_dict': {
                'id': '68093876',
                'ext': 'mp4',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/openstreetmapus',
                'uploader_id': 'openstreetmapus',
                'uploader': 'OpenStreetMap US',
                'title': 'Andy Allan - Putting the Carto into OpenStreetMap Cartography',
                'description': 'md5:2c362968038d4499f4d79f88458590c1',
                'duration': 1595,
                'upload_date': '20130610',
                'timestamp': 1370893156,
            },
            'params': {
                'format': 'best[protocol=https]',
            },
        },
        {
            'url': 'http://player.vimeo.com/video/54469442',
            'md5': '619b811a4417aa4abe78dc653becf511',
            'note': 'Videos that embed the url in the player page',
            'info_dict': {
                'id': '54469442',
                'ext': 'mp4',
                'title': 'Kathy Sierra: Building the minimum Badass User, Business of Software 2012',
                'uploader': 'The BLN & Business of Software',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/theblnbusinessofsoftware',
                'uploader_id': 'theblnbusinessofsoftware',
                'duration': 3610,
                'description': None,
            },
            'params': {
                'format': 'best[protocol=https]',
            },
            'expected_warnings': ['Unable to download JSON metadata'],
        },
        {
            'url': 'http://vimeo.com/68375962',
            'md5': 'aaf896bdb7ddd6476df50007a0ac0ae7',
            'note': 'Video protected with password',
            'info_dict': {
                'id': '68375962',
                'ext': 'mp4',
                'title': 'youtube-dl password protected test video',
                'timestamp': 1371200155,
                'upload_date': '20130614',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/user18948128',
                'uploader_id': 'user18948128',
                'uploader': 'Jaime Marquínez Ferrándiz',
                'duration': 10,
                'description': 'md5:dca3ea23adb29ee387127bc4ddfce63f',
            },
            'params': {
                'format': 'best[protocol=https]',
                'videopassword': 'youtube-dl',
            },
        },
        {
            'url': 'http://vimeo.com/channels/keypeele/75629013',
            'md5': '2f86a05afe9d7abc0b9126d229bbe15d',
            'info_dict': {
                'id': '75629013',
                'ext': 'mp4',
                'title': 'Key & Peele: Terrorist Interrogation',
                'description': 'md5:8678b246399b070816b12313e8b4eb5c',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/atencio',
                'uploader_id': 'atencio',
                'uploader': 'Peter Atencio',
                'channel_id': 'keypeele',
                'channel_url': r're:https?://(?:www\.)?vimeo\.com/channels/keypeele',
                'timestamp': 1380339469,
                'upload_date': '20130928',
                'duration': 187,
            },
            'expected_warnings': ['Unable to download JSON metadata'],
        },
        {
            'url': 'http://vimeo.com/76979871',
            'note': 'Video with subtitles',
            'info_dict': {
                'id': '76979871',
                'ext': 'mp4',
                'title': 'The New Vimeo Player (You Know, For Videos)',
                'description': 'md5:2ec900bf97c3f389378a96aee11260ea',
                'timestamp': 1381846109,
                'upload_date': '20131015',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/staff',
                'uploader_id': 'staff',
                'uploader': 'Vimeo Staff',
                'duration': 62,
            }
        },
        {
            # from https://www.ouya.tv/game/Pier-Solar-and-the-Great-Architects/
            'url': 'https://player.vimeo.com/video/98044508',
            'note': 'The js code contains assignments to the same variable as the config',
            'info_dict': {
                'id': '98044508',
                'ext': 'mp4',
                'title': 'Pier Solar OUYA Official Trailer',
                'uploader': 'Tulio Gonçalves',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/user28849593',
                'uploader_id': 'user28849593',
            },
        },
        {
            # contains original format
            'url': 'https://vimeo.com/33951933',
            'md5': '53c688fa95a55bf4b7293d37a89c5c53',
            'info_dict': {
                'id': '33951933',
                'ext': 'mp4',
                'title': 'FOX CLASSICS - Forever Classic ID - A Full Minute',
                'uploader': 'The DMCI',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/dmci',
                'uploader_id': 'dmci',
                'timestamp': 1324343742,
                'upload_date': '20111220',
                'description': 'md5:ae23671e82d05415868f7ad1aec21147',
            },
        },
        {
            # only available via https://vimeo.com/channels/tributes/6213729 and
            # not via https://vimeo.com/6213729
            'url': 'https://vimeo.com/channels/tributes/6213729',
            'info_dict': {
                'id': '6213729',
                'ext': 'mp4',
                'title': 'Vimeo Tribute: The Shining',
                'uploader': 'Casey Donahue',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/caseydonahue',
                'uploader_id': 'caseydonahue',
                'channel_url': r're:https?://(?:www\.)?vimeo\.com/channels/tributes',
                'channel_id': 'tributes',
                'timestamp': 1250886430,
                'upload_date': '20090821',
                'description': 'md5:bdbf314014e58713e6e5b66eb252f4a6',
            },
            'params': {
                'skip_download': True,
            },
            'expected_warnings': ['Unable to download JSON metadata'],
        },
        {
            # redirects to ondemand extractor and should be passed through it
            # for successful extraction
            'url': 'https://vimeo.com/73445910',
            'info_dict': {
                'id': '73445910',
                'ext': 'mp4',
                'title': 'The Reluctant Revolutionary',
                'uploader': '10Ft Films',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/tenfootfilms',
                'uploader_id': 'tenfootfilms',
                'description': 'md5:0fa704e05b04f91f40b7f3ca2e801384',
                'upload_date': '20130830',
                'timestamp': 1377853339,
            },
            'params': {
                'skip_download': True,
            },
            'expected_warnings': ['Unable to download JSON metadata'],
        },
        {
            'url': 'http://player.vimeo.com/video/68375962',
            'md5': 'aaf896bdb7ddd6476df50007a0ac0ae7',
            'info_dict': {
                'id': '68375962',
                'ext': 'mp4',
                'title': 'youtube-dl password protected test video',
                'uploader_url': r're:https?://(?:www\.)?vimeo\.com/user18948128',
                'uploader_id': 'user18948128',
                'uploader': 'Jaime Marquínez Ferrándiz',
                'duration': 10,
            },
            'params': {
                'format': 'best[protocol=https]',
                'videopassword': 'youtube-dl',
            },
        },
        {
            'url': 'http://vimeo.com/moogaloop.swf?clip_id=2539741',
            'only_matching': True,
        },
        {
            'url': 'https://vimeo.com/109815029',
            'note': 'Video not completely processed, "failed" seed status',
            'only_matching': True,
        },
        {
            'url': 'https://vimeo.com/groups/travelhd/videos/22439234',
            'only_matching': True,
        },
        {
            'url': 'https://vimeo.com/album/2632481/video/79010983',
            'only_matching': True,
        },
        {
            # source file returns 403: Forbidden
            'url': 'https://vimeo.com/7809605',
            'only_matching': True,
        },
        {
            'url': 'https://vimeo.com/160743502/abd0e13fb4',
            'only_matching': True,
        }
        # https://gettingthingsdone.com/workflowmap/
        # vimeo embed with check-password page protected by Referer header
    ]

    @staticmethod
    def _smuggle_referrer(url, referrer_url):
        return smuggle_url(url, {'http_headers': {'Referer': referrer_url}})

    @staticmethod
    def _extract_urls(url, webpage):
        urls = []
        # Look for embedded (iframe) Vimeo player
        for mobj in re.finditer(
                r'<iframe[^>]+?src=(["\'])(?P<url>(?:https?:)?//player\.vimeo\.com/video/\d+.*?)\1',
                webpage):
            urls.append(VimeoIE._smuggle_referrer(unescapeHTML(mobj.group('url')), url))
        PLAIN_EMBED_RE = (
            # Look for embedded (swf embed) Vimeo player
            r'<embed[^>]+?src=(["\'])(?P<url>(?:https?:)?//(?:www\.)?vimeo\.com/moogaloop\.swf.+?)\1',
            # Look more for non-standard embedded Vimeo player
            r'<video[^>]+src=(["\'])(?P<url>(?:https?:)?//(?:www\.)?vimeo\.com/[0-9]+)\1',
        )
        for embed_re in PLAIN_EMBED_RE:
            for mobj in re.finditer(embed_re, webpage):
                urls.append(mobj.group('url'))
        return urls

    @staticmethod
    def _extract_url(url, webpage):
        urls = VimeoIE._extract_urls(url, webpage)
        return urls[0] if urls else None

    def _verify_player_video_password(self, url, video_id, headers):
        password = self._downloader.params.get('videopassword')
        if password is None:
            raise ExtractorError('This video is protected by a password, use the --video-password option', expected=True)
        data = urlencode_postdata({
            'password': base64.b64encode(password.encode()),
        })
        headers = merge_dicts(headers, {
            'Content-Type': 'application/x-www-form-urlencoded',
        })
        checked = self._download_json(
            url + '/check-password', video_id,
            'Verifying the password', data=data, headers=headers)
        if checked is False:
            raise ExtractorError('Wrong video password', expected=True)
        return checked

    def _real_initialize(self):
        self._login()

    def _real_extract(self, url):
        url, data = unsmuggle_url(url, {})
        headers = std_headers.copy()
        if 'http_headers' in data:
            headers.update(data['http_headers'])
        if 'Referer' not in headers:
            headers['Referer'] = url

        channel_id = self._search_regex(
            r'vimeo\.com/channels/([^/]+)', url, 'channel id', default=None)

        # Extract ID from URL
        video_id = self._match_id(url)
        orig_url = url
        is_pro = 'vimeopro.com/' in url
        is_player = '://player.vimeo.com/video/' in url
        if is_pro:
            # some videos require portfolio_id to be present in player url
            # https://github.com/ytdl-org/youtube-dl/issues/20070
            url = self._extract_url(url, self._download_webpage(url, video_id))
            if not url:
                url = 'https://vimeo.com/' + video_id
        elif is_player:
            url = 'https://player.vimeo.com/video/' + video_id
        elif any(p in url for p in ('play_redirect_hls', 'moogaloop.swf')):
            url = 'https://vimeo.com/' + video_id

        try:
            # Retrieve video webpage to extract further information
            webpage, urlh = self._download_webpage_handle(
                url, video_id, headers=headers)
            redirect_url = urlh.geturl()
        except ExtractorError as ee:
            if isinstance(ee.cause, compat_HTTPError) and ee.cause.code == 403:
                errmsg = ee.cause.read()
                if b'Because of its privacy settings, this video cannot be played here' in errmsg:
                    raise ExtractorError(
                        'Cannot download embed-only video without embedding '
                        'URL. Please call youtube-dl with the URL of the page '
                        'that embeds this video.',
                        expected=True)
            raise

        # Now we begin extracting as much information as we can from what we
        # retrieved. First we extract the information common to all extractors,
        # and latter we extract those that are Vimeo specific.
        self.report_extraction(video_id)

        vimeo_config = self._extract_vimeo_config(webpage, video_id, default=None)
        if vimeo_config:
            seed_status = vimeo_config.get('seed_status', {})
            if seed_status.get('state') == 'failed':
                raise ExtractorError(
                    '%s said: %s' % (self.IE_NAME, seed_status['title']),
                    expected=True)

        cc_license = None
        timestamp = None
        video_description = None

        # Extract the config JSON
        try:
            try:
                config_url = self._html_search_regex(
                    r' data-config-url="(.+?)"', webpage,
                    'config URL', default=None)
                if not config_url:
                    # Sometimes new react-based page is served instead of old one that require
                    # different config URL extraction approach (see
                    # https://github.com/ytdl-org/youtube-dl/pull/7209)
                    page_config = self._parse_json(self._search_regex(
                        r'vimeo\.(?:clip|vod_title)_page_config\s*=\s*({.+?});',
                        webpage, 'page config'), video_id)
                    config_url = page_config['player']['config_url']
                    cc_license = page_config.get('cc_license')
                    timestamp = try_get(
                        page_config, lambda x: x['clip']['uploaded_on'],
                        compat_str)
                    video_description = clean_html(dict_get(
                        page_config, ('description', 'description_html_escaped')))
                config = self._download_json(config_url, video_id)
            except RegexNotFoundError:
                # For pro videos or player.vimeo.com urls
                # We try to find out to which variable is assigned the config dic
                m_variable_name = re.search(r'(\w)\.video\.id', webpage)
                if m_variable_name is not None:
                    config_re = [r'%s=({[^}].+?});' % re.escape(m_variable_name.group(1))]
                else:
                    config_re = [r' = {config:({.+?}),assets:', r'(?:[abc])=({.+?});']
                config_re.append(r'\bvar\s+r\s*=\s*({.+?})\s*;')
                config_re.append(r'\bconfig\s*=\s*({.+?})\s*;')
                config = self._search_regex(config_re, webpage, 'info section',
                                            flags=re.DOTALL)
                config = json.loads(config)
        except Exception as e:
            if re.search('The creator of this video has not given you permission to embed it on this domain.', webpage):
                raise ExtractorError('The author has restricted the access to this video, try with the "--referer" option')

            if re.search(r'<form[^>]+?id="pw_form"', webpage) is not None:
                if '_video_password_verified' in data:
                    raise ExtractorError('video password verification failed!')
                self._verify_video_password(redirect_url, video_id, webpage)
                return self._real_extract(
                    smuggle_url(redirect_url, {'_video_password_verified': 'verified'}))
            else:
                raise ExtractorError('Unable to extract info section',
                                     cause=e)
        else:
            if config.get('view') == 4:
                config = self._verify_player_video_password(redirect_url, video_id, headers)

        vod = config.get('video', {}).get('vod', {})

        def is_rented():
            if '>You rented this title.<' in webpage:
                return True
            if config.get('user', {}).get('purchased'):
                return True
            for purchase_option in vod.get('purchase_options', []):
                if purchase_option.get('purchased'):
                    return True
                label = purchase_option.get('label_string')
                if label and (label.startswith('You rented this') or label.endswith(' remaining')):
                    return True
            return False

        if is_rented() and vod.get('is_trailer'):
            feature_id = vod.get('feature_id')
            if feature_id and not data.get('force_feature_id', False):
                return self.url_result(smuggle_url(
                    'https://player.vimeo.com/player/%s' % feature_id,
                    {'force_feature_id': True}), 'Vimeo')

        # Extract video description
        if not video_description:
            video_description = self._html_search_regex(
                r'(?s)<div\s+class="[^"]*description[^"]*"[^>]*>(.*?)</div>',
                webpage, 'description', default=None)
        if not video_description:
            video_description = self._html_search_meta(
                'description', webpage, default=None)
        if not video_description and is_pro:
            orig_webpage = self._download_webpage(
                orig_url, video_id,
                note='Downloading webpage for description',
                fatal=False)
            if orig_webpage:
                video_description = self._html_search_meta(
                    'description', orig_webpage, default=None)
        if not video_description and not is_player:
            self._downloader.report_warning('Cannot find video description')

        # Extract upload date
        if not timestamp:
            timestamp = self._search_regex(
                r'<time[^>]+datetime="([^"]+)"', webpage,
                'timestamp', default=None)

        try:
            view_count = int(self._search_regex(r'UserPlays:(\d+)', webpage, 'view count'))
            like_count = int(self._search_regex(r'UserLikes:(\d+)', webpage, 'like count'))
            comment_count = int(self._search_regex(r'UserComments:(\d+)', webpage, 'comment count'))
        except RegexNotFoundError:
            # This info is only available in vimeo.com/{id} urls
            view_count = None
            like_count = None
            comment_count = None

        formats = []

        source_format = self._extract_original_format(
            'https://vimeo.com/' + video_id, video_id)
        if source_format:
            formats.append(source_format)

        info_dict_config = self._parse_config(config, video_id)
        formats.extend(info_dict_config['formats'])
        self._vimeo_sort_formats(formats)

        json_ld = self._search_json_ld(webpage, video_id, default={})

        if not cc_license:
            cc_license = self._search_regex(
                r'<link[^>]+rel=["\']license["\'][^>]+href=(["\'])(?P<license>(?:(?!\1).)+)\1',
                webpage, 'license', default=None, group='license')

        channel_url = 'https://vimeo.com/channels/%s' % channel_id if channel_id else None

        info_dict = {
            'formats': formats,
            'timestamp': unified_timestamp(timestamp),
            'description': video_description,
            'webpage_url': url,
            'view_count': view_count,
            'like_count': like_count,
            'comment_count': comment_count,
            'license': cc_license,
            'channel_id': channel_id,
            'channel_url': channel_url,
        }

        info_dict = merge_dicts(info_dict, info_dict_config, json_ld)

        return info_dict


class VimeoOndemandIE(VimeoIE):
    IE_NAME = 'vimeo:ondemand'
    _VALID_URL = r'https?://(?:www\.)?vimeo\.com/ondemand/([^/]+/)?(?P<id>[^/?#&]+)'
    _TESTS = [{
        # ondemand video not available via https://vimeo.com/id
        'url': 'https://vimeo.com/ondemand/20704',
        'md5': 'c424deda8c7f73c1dfb3edd7630e2f35',
        'info_dict': {
            'id': '105442900',
            'ext': 'mp4',
            'title': 'המעבדה - במאי יותם פלדמן',
            'uploader': 'גם סרטים',
            'uploader_url': r're:https?://(?:www\.)?vimeo\.com/gumfilms',
            'uploader_id': 'gumfilms',
            'description': 'md5:4c027c965e439de4baab621e48b60791',
            'upload_date': '20140906',
            'timestamp': 1410032453,
        },
        'params': {
            'format': 'best[protocol=https]',
        },
        'expected_warnings': ['Unable to download JSON metadata'],
    }, {
        # requires Referer to be passed along with og:video:url
        'url': 'https://vimeo.com/ondemand/36938/126682985',
        'info_dict': {
            'id': '126584684',
            'ext': 'mp4',
            'title': 'Rävlock, rätt läte på rätt plats',
            'uploader': 'Lindroth & Norin',
            'uploader_url': r're:https?://(?:www\.)?vimeo\.com/lindrothnorin',
            'uploader_id': 'lindrothnorin',
            'description': 'md5:c3c46a90529612c8279fb6af803fc0df',
            'upload_date': '20150502',
            'timestamp': 1430586422,
        },
        'params': {
            'skip_download': True,
        },
        'expected_warnings': ['Unable to download JSON metadata'],
    }, {
        'url': 'https://vimeo.com/ondemand/nazmaalik',
        'only_matching': True,
    }, {
        'url': 'https://vimeo.com/ondemand/141692381',
        'only_matching': True,
    }, {
        'url': 'https://vimeo.com/ondemand/thelastcolony/150274832',
        'only_matching': True,
    }]


class VimeoChannelIE(VimeoBaseInfoExtractor):
    IE_NAME = 'vimeo:channel'
    _VALID_URL = r'https://vimeo\.com/channels/(?P<id>[^/?#]+)/?(?:$|[?#])'
    _MORE_PAGES_INDICATOR = r'<a.+?rel="next"'
    _TITLE = None
    _TITLE_RE = r'<link rel="alternate"[^>]+?title="(.*?)"'
    _TESTS = [{
        'url': 'https://vimeo.com/channels/tributes',
        'info_dict': {
            'id': 'tributes',
            'title': 'Vimeo Tributes',
        },
        'playlist_mincount': 25,
    }]
    _BASE_URL_TEMPL = 'https://vimeo.com/channels/%s'

    def _page_url(self, base_url, pagenum):
        return '%s/videos/page:%d/' % (base_url, pagenum)

    def _extract_list_title(self, webpage):
        return self._TITLE or self._html_search_regex(
            self._TITLE_RE, webpage, 'list title', fatal=False)

    def _title_and_entries(self, list_id, base_url):
        for pagenum in itertools.count(1):
            page_url = self._page_url(base_url, pagenum)
            webpage = self._download_webpage(
                page_url, list_id,
                'Downloading page %s' % pagenum)

            if pagenum == 1:
                yield self._extract_list_title(webpage)

            # Try extracting href first since not all videos are available via
            # short https://vimeo.com/id URL (e.g. https://vimeo.com/channels/tributes/6213729)
            clips = re.findall(
                r'id="clip_(\d+)"[^>]*>\s*<a[^>]+href="(/(?:[^/]+/)*\1)(?:[^>]+\btitle="([^"]+)")?', webpage)
            if clips:
                for video_id, video_url, video_title in clips:
                    yield self.url_result(
                        compat_urlparse.urljoin(base_url, video_url),
                        VimeoIE.ie_key(), video_id=video_id, video_title=video_title)
            # More relaxed fallback
            else:
                for video_id in re.findall(r'id=["\']clip_(\d+)', webpage):
                    yield self.url_result(
                        'https://vimeo.com/%s' % video_id,
                        VimeoIE.ie_key(), video_id=video_id)

            if re.search(self._MORE_PAGES_INDICATOR, webpage, re.DOTALL) is None:
                break

    def _extract_videos(self, list_id, base_url):
        title_and_entries = self._title_and_entries(list_id, base_url)
        list_title = next(title_and_entries)
        return self.playlist_result(title_and_entries, list_id, list_title)

    def _real_extract(self, url):
        channel_id = self._match_id(url)
        return self._extract_videos(channel_id, self._BASE_URL_TEMPL % channel_id)


class VimeoUserIE(VimeoChannelIE):
    IE_NAME = 'vimeo:user'
    _VALID_URL = r'https://vimeo\.com/(?!(?:[0-9]+|watchlater)(?:$|[?#/]))(?P<id>[^/]+)(?:/videos|[#?]|$)'
    _TITLE_RE = r'<a[^>]+?class="user">([^<>]+?)</a>'
    _TESTS = [{
        'url': 'https://vimeo.com/nkistudio/videos',
        'info_dict': {
            'title': 'Nki',
            'id': 'nkistudio',
        },
        'playlist_mincount': 66,
    }]
    _BASE_URL_TEMPL = 'https://vimeo.com/%s'


class VimeoAlbumIE(VimeoBaseInfoExtractor):
    IE_NAME = 'vimeo:album'
    _VALID_URL = r'https://vimeo\.com/(?:album|showcase)/(?P<id>\d+)(?:$|[?#]|/(?!video))'
    _TITLE_RE = r'<header id="page_header">\n\s*<h1>(.*?)</h1>'
    _TESTS = [{
        'url': 'https://vimeo.com/album/2632481',
        'info_dict': {
            'id': '2632481',
            'title': 'Staff Favorites: November 2013',
        },
        'playlist_mincount': 13,
    }, {
        'note': 'Password-protected album',
        'url': 'https://vimeo.com/album/3253534',
        'info_dict': {
            'title': 'test',
            'id': '3253534',
        },
        'playlist_count': 1,
        'params': {
            'videopassword': 'youtube-dl',
        }
    }]
    _PAGE_SIZE = 100

    def _fetch_page(self, album_id, authorization, hashed_pass, page):
        api_page = page + 1
        query = {
            'fields': 'link,uri',
            'page': api_page,
            'per_page': self._PAGE_SIZE,
        }
        if hashed_pass:
            query['_hashed_pass'] = hashed_pass
        videos = self._download_json(
            'https://api.vimeo.com/albums/%s/videos' % album_id,
            album_id, 'Downloading page %d' % api_page, query=query, headers={
                'Authorization': 'jwt ' + authorization,
            })['data']
        for video in videos:
            link = video.get('link')
            if not link:
                continue
            uri = video.get('uri')
            video_id = self._search_regex(r'/videos/(\d+)', uri, 'video_id', default=None) if uri else None
            yield self.url_result(link, VimeoIE.ie_key(), video_id)

    def _real_extract(self, url):
        album_id = self._match_id(url)
        viewer = self._download_json(
            'https://vimeo.com/_rv/viewer', album_id, fatal=False)
        if not viewer:
            webpage = self._download_webpage(url, album_id)
            viewer = self._parse_json(self._search_regex(
                r'bootstrap_data\s*=\s*({.+?})</script>',
                webpage, 'bootstrap data'), album_id)['viewer']
        jwt = viewer['jwt']
        album = self._download_json(
            'https://api.vimeo.com/albums/' + album_id,
            album_id, headers={'Authorization': 'jwt ' + jwt},
            query={'fields': 'description,name,privacy'})
        hashed_pass = None
        if try_get(album, lambda x: x['privacy']['view']) == 'password':
            password = self._downloader.params.get('videopassword')
            if not password:
                raise ExtractorError(
                    'This album is protected by a password, use the --video-password option',
                    expected=True)
            self._set_vimeo_cookie('vuid', viewer['vuid'])
            try:
                hashed_pass = self._download_json(
                    'https://vimeo.com/showcase/%s/auth' % album_id,
                    album_id, 'Verifying the password', data=urlencode_postdata({
                        'password': password,
                        'token': viewer['xsrft'],
                    }), headers={
                        'X-Requested-With': 'XMLHttpRequest',
                    })['hashed_pass']
            except ExtractorError as e:
                if isinstance(e.cause, compat_HTTPError) and e.cause.code == 401:
                    raise ExtractorError('Wrong password', expected=True)
                raise
        entries = OnDemandPagedList(functools.partial(
            self._fetch_page, album_id, jwt, hashed_pass), self._PAGE_SIZE)
        return self.playlist_result(
            entries, album_id, album.get('name'), album.get('description'))


class VimeoGroupsIE(VimeoChannelIE):
    IE_NAME = 'vimeo:group'
    _VALID_URL = r'https://vimeo\.com/groups/(?P<id>[^/]+)(?:/(?!videos?/\d+)|$)'
    _TESTS = [{
        'url': 'https://vimeo.com/groups/kattykay',
        'info_dict': {
            'id': 'kattykay',
            'title': 'Katty Kay',
        },
        'playlist_mincount': 27,
    }]
    _BASE_URL_TEMPL = 'https://vimeo.com/groups/%s'


class VimeoReviewIE(VimeoBaseInfoExtractor):
    IE_NAME = 'vimeo:review'
    IE_DESC = 'Review pages on vimeo'
    _VALID_URL = r'(?P<url>https://vimeo\.com/[^/]+/review/(?P<id>[^/]+)/[0-9a-f]{10})'
    _TESTS = [{
        'url': 'https://vimeo.com/user21297594/review/75524534/3c257a1b5d',
        'md5': 'c507a72f780cacc12b2248bb4006d253',
        'info_dict': {
            'id': '75524534',
            'ext': 'mp4',
            'title': "DICK HARDWICK 'Comedian'",
            'uploader': 'Richard Hardwick',
            'uploader_id': 'user21297594',
            'description': "Comedian Dick Hardwick's five minute demo filmed in front of a live theater audience.\nEdit by Doug Mattocks",
        },
        'expected_warnings': ['Unable to download JSON metadata'],
    }, {
        'note': 'video player needs Referer',
        'url': 'https://vimeo.com/user22258446/review/91613211/13f927e053',
        'md5': '6295fdab8f4bf6a002d058b2c6dce276',
        'info_dict': {
            'id': '91613211',
            'ext': 'mp4',
            'title': 're:(?i)^Death by dogma versus assembling agile . Sander Hoogendoorn',
            'uploader': 'DevWeek Events',
            'duration': 2773,
            'thumbnail': r're:^https?://.*\.jpg$',
            'uploader_id': 'user22258446',
        },
        'skip': 'video gone',
    }, {
        'note': 'Password protected',
        'url': 'https://vimeo.com/user37284429/review/138823582/c4d865efde',
        'info_dict': {
            'id': '138823582',
            'ext': 'mp4',
            'title': 'EFFICIENT PICKUP MASTERCLASS MODULE 1',
            'uploader': 'TMB',
            'uploader_id': 'user37284429',
        },
        'params': {
            'videopassword': 'holygrail',
        },
        'skip': 'video gone',
    }]

    def _real_initialize(self):
        self._login()

    def _real_extract(self, url):
        page_url, video_id = re.match(self._VALID_URL, url).groups()
        clip_data = self._download_json(
            page_url.replace('/review/', '/review/data/'),
            video_id)['clipData']
        config_url = clip_data['configUrl']
        config = self._download_json(config_url, video_id)
        info_dict = self._parse_config(config, video_id)
        source_format = self._extract_original_format(
            page_url + '/action', video_id)
        if source_format:
            info_dict['formats'].append(source_format)
        self._vimeo_sort_formats(info_dict['formats'])
        info_dict['description'] = clean_html(clip_data.get('description'))
        return info_dict


class VimeoWatchLaterIE(VimeoChannelIE):
    IE_NAME = 'vimeo:watchlater'
    IE_DESC = 'Vimeo watch later list, "vimeowatchlater" keyword (requires authentication)'
    _VALID_URL = r'https://vimeo\.com/(?:home/)?watchlater|:vimeowatchlater'
    _TITLE = 'Watch Later'
    _LOGIN_REQUIRED = True
    _TESTS = [{
        'url': 'https://vimeo.com/watchlater',
        'only_matching': True,
    }]

    def _real_initialize(self):
        self._login()

    def _page_url(self, base_url, pagenum):
        url = '%s/page:%d/' % (base_url, pagenum)
        request = sanitized_Request(url)
        # Set the header to get a partial html page with the ids,
        # the normal page doesn't contain them.
        request.add_header('X-Requested-With', 'XMLHttpRequest')
        return request

    def _real_extract(self, url):
        return self._extract_videos('watchlater', 'https://vimeo.com/watchlater')


class VimeoLikesIE(VimeoChannelIE):
    _VALID_URL = r'https://(?:www\.)?vimeo\.com/(?P<id>[^/]+)/likes/?(?:$|[?#]|sort:)'
    IE_NAME = 'vimeo:likes'
    IE_DESC = 'Vimeo user likes'
    _TESTS = [{
        'url': 'https://vimeo.com/user755559/likes/',
        'playlist_mincount': 293,
        'info_dict': {
            'id': 'user755559',
            'title': 'urza’s Likes',
        },
    }, {
        'url': 'https://vimeo.com/stormlapse/likes',
        'only_matching': True,
    }]

    def _page_url(self, base_url, pagenum):
        return '%s/page:%d/' % (base_url, pagenum)

    def _real_extract(self, url):
        user_id = self._match_id(url)
        return self._extract_videos(user_id, 'https://vimeo.com/%s/likes' % user_id)


class VHXEmbedIE(VimeoBaseInfoExtractor):
    IE_NAME = 'vhx:embed'
    _VALID_URL = r'https?://embed\.vhx\.tv/videos/(?P<id>\d+)'

    @staticmethod
    def _extract_url(webpage):
        mobj = re.search(
            r'<iframe[^>]+src="(https?://embed\.vhx\.tv/videos/\d+[^"]*)"', webpage)
        return unescapeHTML(mobj.group(1)) if mobj else None

    def _real_extract(self, url):
        video_id = self._match_id(url)
        webpage = self._download_webpage(url, video_id)
        config_url = self._parse_json(self._search_regex(
            r'window\.OTTData\s*=\s*({.+})', webpage,
            'ott data'), video_id, js_to_json)['config_url']
        config = self._download_json(config_url, video_id)
        info = self._parse_config(config, video_id)
        info['id'] = video_id
        self._vimeo_sort_formats(info['formats'])
        return info

Filemanager

Name Type Size Permission Actions
__pycache__ Folder 2755
__init__.py File 1.23 KB 0644
abc.py File 7.32 KB 0644
abcnews.py File 5.31 KB 0644
abcotvs.py File 4.63 KB 0644
academicearth.py File 1.37 KB 0644
acast.py File 4.39 KB 0644
adn.py File 9.9 KB 0644
adobeconnect.py File 1.32 KB 0644
adobepass.py File 40.44 KB 0644
adobetv.py File 10.05 KB 0644
adultswim.py File 7.67 KB 0644
aenetworks.py File 11.81 KB 0644
afreecatv.py File 14.22 KB 0644
airmozilla.py File 2.63 KB 0644
aliexpress.py File 1.54 KB 0644
aljazeera.py File 2.18 KB 0644
allocine.py File 4.85 KB 0644
alphaporno.py File 2.66 KB 0644
amara.py File 3.5 KB 0644
amcnetworks.py File 4.85 KB 0644
americastestkitchen.py File 6.2 KB 0644
amp.py File 3.97 KB 0644
animeondemand.py File 12.24 KB 0644
anvato.py File 24.41 KB 0644
aol.py File 5.52 KB 0644
apa.py File 3.1 KB 0644
aparat.py File 3.13 KB 0644
appleconnect.py File 1.71 KB 0644
applepodcasts.py File 2.26 KB 0644
appletrailers.py File 10.09 KB 0644
archiveorg.py File 2.43 KB 0644
arcpublishing.py File 7.78 KB 0644
ard.py File 16.39 KB 0644
arkena.py File 7.35 KB 0644
arte.py File 10.36 KB 0644
asiancrush.py File 7.62 KB 0644
atresplayer.py File 4.28 KB 0644
atttechchannel.py File 1.92 KB 0644
atvat.py File 2.45 KB 0644
audimedia.py File 3.93 KB 0644
audioboom.py File 2.6 KB 0644
audiomack.py File 5.73 KB 0644
awaan.py File 6.98 KB 0644
aws.py File 3.02 KB 0644
azmedien.py File 2.21 KB 0644
baidu.py File 1.93 KB 0644
bandcamp.py File 14.03 KB 0644
bbc.py File 58.62 KB 0644
beatport.py File 3.34 KB 0644
beeg.py File 3.5 KB 0644
behindkink.py File 1.61 KB 0644
bellmedia.py File 2.9 KB 0644
bet.py File 2.72 KB 0644
bfi.py File 1.31 KB 0644
bfmtv.py File 4.12 KB 0644
bibeltv.py File 1.08 KB 0644
bigflix.py File 2.28 KB 0644
bild.py File 1.33 KB 0644
bilibili.py File 16.18 KB 0644
biobiochiletv.py File 3.43 KB 0644
biqle.py File 3.77 KB 0644
bitchute.py File 5.2 KB 0644
bleacherreport.py File 4.11 KB 0644
blinkx.py File 3.14 KB 0644
bloomberg.py File 3.25 KB 0644
bokecc.py File 2.01 KB 0644
bongacams.py File 1.86 KB 0644
bostonglobe.py File 3.12 KB 0644
box.py File 3.71 KB 0644
bpb.py File 2.15 KB 0644
br.py File 11.62 KB 0644
bravotv.py File 3.38 KB 0644
breakcom.py File 2.88 KB 0644
brightcove.py File 29.8 KB 0644
businessinsider.py File 1.95 KB 0644
buzzfeed.py File 3.57 KB 0644
byutv.py File 4.07 KB 0644
c56.py File 2.03 KB 0644
camdemy.py File 5.64 KB 0644
cammodels.py File 3.4 KB 0644
camtube.py File 2.16 KB 0644
camwithher.py File 3.15 KB 0644
canalc2.py File 2.26 KB 0644
canalplus.py File 4.37 KB 0644
canvas.py File 12.91 KB 0644
carambatv.py File 3.44 KB 0644
cartoonnetwork.py File 2.32 KB 0644
cbc.py File 20.17 KB 0644
cbs.py File 4.57 KB 0644
cbsinteractive.py File 3.95 KB 0644
cbslocal.py File 4.02 KB 0644
cbsnews.py File 7.44 KB 0644
cbssports.py File 1.45 KB 0644
ccc.py File 3.78 KB 0644
ccma.py File 3.62 KB 0644
cctv.py File 6.74 KB 0644
cda.py File 7.99 KB 0644
ceskatelevize.py File 10.41 KB 0644
channel9.py File 10.04 KB 0644
charlierose.py File 1.79 KB 0644
chaturbate.py File 3.82 KB 0644
chilloutzone.py File 3.42 KB 0644
chirbit.py File 2.88 KB 0644
cinchcast.py File 1.95 KB 0644
cinemax.py File 949 B 0644
ciscolive.py File 5.88 KB 0644
cjsw.py File 2.36 KB 0644
cliphunter.py File 2.47 KB 0644
clippit.py File 2.49 KB 0644
cliprs.py File 1.01 KB 0644
clipsyndicate.py File 1.77 KB 0644
closertotruth.py File 3.02 KB 0644
cloudflarestream.py File 2.61 KB 0644
cloudy.py File 1.85 KB 0644
clubic.py File 1.93 KB 0644
clyp.py File 2.44 KB 0644
cmt.py File 2.12 KB 0644
cnbc.py File 2.24 KB 0644
cnn.py File 6.37 KB 0644
comedycentral.py File 1.99 KB 0644
common.py File 140.53 KB 0644
commonmistakes.py File 1.5 KB 0644
commonprotocols.py File 1.63 KB 0644
condenast.py File 9.51 KB 0644
contv.py File 4.1 KB 0644
corus.py File 6.25 KB 0644
coub.py File 4.45 KB 0644
cracked.py File 3.06 KB 0644
crackle.py File 7.45 KB 0644
crooksandliars.py File 2.01 KB 0644
crunchyroll.py File 28.07 KB 0644
cspan.py File 10.04 KB 0644
ctsnews.py File 3.56 KB 0644
ctv.py File 1.73 KB 0644
ctvnews.py File 2.22 KB 0644
cultureunplugged.py File 2.45 KB 0644
curiositystream.py File 5.84 KB 0644
cwtv.py File 3.75 KB 0644
dailymail.py File 3.06 KB 0644
dailymotion.py File 14.77 KB 0644
daum.py File 9.49 KB 0644
dbtv.py File 1.91 KB 0644
dctp.py File 3.5 KB 0644
deezer.py File 3.2 KB 0644
defense.py File 1.21 KB 0644
democracynow.py File 3.03 KB 0644
dfb.py File 2.2 KB 0644
dhm.py File 2.04 KB 0644
digg.py File 1.84 KB 0644
digiteka.py File 3.43 KB 0644
discovery.py File 4.8 KB 0644
discoverygo.py File 5.94 KB 0644
discoverynetworks.py File 1.6 KB 0644
discoveryvr.py File 2.08 KB 0644
disney.py File 6.88 KB 0644
dispeak.py File 4.55 KB 0644
dlive.py File 3.05 KB 0644
dotsub.py File 3.01 KB 0644
douyutv.py File 6.72 KB 0644
dplay.py File 10.6 KB 0644
drbonanza.py File 1.93 KB 0644
dreisat.py File 7.5 KB 0644
dropbox.py File 1.27 KB 0644
drtuber.py File 3.88 KB 0644
drtv.py File 13.59 KB 0644
dtube.py File 2.73 KB 0644
dumpert.py File 2.64 KB 0644
dvtv.py File 7.48 KB 0644
dw.py File 4 KB 0644
eagleplatform.py File 7.55 KB 0644
ebaumsworld.py File 1.06 KB 0644
echomsk.py File 1.29 KB 0644
egghead.py File 4.54 KB 0644
ehow.py File 1.48 KB 0644
eighttracks.py File 5.73 KB 0644
einthusan.py File 3.63 KB 0644
eitb.py File 3.2 KB 0644
ellentube.py File 4.79 KB 0644
elpais.py File 4.26 KB 0644
embedly.py File 842 B 0644
engadget.py File 807 B 0644
eporner.py File 4.56 KB 0644
eroprofile.py File 3.14 KB 0644
escapist.py File 3.54 KB 0644
espn.py File 8.55 KB 0644
esri.py File 2.57 KB 0644
europa.py File 3.33 KB 0644
expotv.py File 2.84 KB 0644
expressen.py File 3.77 KB 0644
extractors.py File 34.55 KB 0644
extremetube.py File 1.71 KB 0644
eyedotv.py File 2.62 KB 0644
facebook.py File 29.36 KB 0644
faz.py File 3.5 KB 0644
fc2.py File 5.46 KB 0644
fczenit.py File 1.72 KB 0644
filmon.py File 5.91 KB 0644
filmweb.py File 1.44 KB 0644
firsttv.py File 6.31 KB 0644
fivemin.py File 1.87 KB 0644
fivetv.py File 3.13 KB 0644
flickr.py File 4.66 KB 0644
folketinget.py File 2.58 KB 0644
footyroom.py File 1.83 KB 0644
formula1.py File 1.18 KB 0644
fourtube.py File 11.31 KB 0644
fox.py File 5.56 KB 0644
fox9.py File 1.43 KB 0644
foxgay.py File 2.15 KB 0644
foxnews.py File 5.04 KB 0644
foxsports.py File 1.07 KB 0644
franceculture.py File 2.8 KB 0644
franceinter.py File 2.16 KB 0644
francetv.py File 19.69 KB 0644
freesound.py File 2.44 KB 0644
freespeech.py File 1.03 KB 0644
freshlive.py File 2.64 KB 0644
frontendmasters.py File 8.6 KB 0644
fujitv.py File 1.02 KB 0644
funimation.py File 5.54 KB 0644
funk.py File 1.67 KB 0644
fusion.py File 3.09 KB 0644
gaia.py File 4.59 KB 0644
gameinformer.py File 2.07 KB 0644
gamespot.py File 3.08 KB 0644
gamestar.py File 2.56 KB 0644
gaskrank.py File 3.76 KB 0644
gazeta.py File 1.91 KB 0644
gdcvault.py File 7.13 KB 0644
generic.py File 142.73 KB 0644
gfycat.py File 4.12 KB 0644
giantbomb.py File 2.98 KB 0644
giga.py File 3.73 KB 0644
gigya.py File 677 B 0644
glide.py File 1.51 KB 0644
globo.py File 9.56 KB 0644
go.py File 11.37 KB 0644
godtube.py File 1.74 KB 0644
golem.py File 2.16 KB 0644
googledrive.py File 10.29 KB 0644
googlepodcasts.py File 3.33 KB 0644
googlesearch.py File 1.65 KB 0644
goshgay.py File 1.51 KB 0644
gputechconf.py File 1.17 KB 0644
groupon.py File 2.54 KB 0644
hbo.py File 5.98 KB 0644
hearthisat.py File 5.12 KB 0644
heise.py File 6.39 KB 0644
hellporno.py File 2.65 KB 0644
helsinki.py File 1.32 KB 0644
hentaistigma.py File 1.17 KB 0644
hgtv.py File 1.4 KB 0644
hidive.py File 4.02 KB 0644
historicfilms.py File 1.54 KB 0644
hitbox.py File 7.24 KB 0644
hitrecord.py File 2.22 KB 0644
hketv.py File 6.8 KB 0644
hornbunny.py File 1.49 KB 0644
hotnewhiphop.py File 2.23 KB 0644
hotstar.py File 9.23 KB 0644
howcast.py File 1.34 KB 0644
howstuffworks.py File 3.38 KB 0644
hrti.py File 7.03 KB 0644
huajiao.py File 1.81 KB 0644
huffpost.py File 3.31 KB 0644
hungama.py File 3.71 KB 0644
hypem.py File 1.51 KB 0644
ign.py File 8.89 KB 0644
iheart.py File 3.38 KB 0644
imdb.py File 5.13 KB 0644
imggaming.py File 4.99 KB 0644
imgur.py File 4.96 KB 0644
ina.py File 2.88 KB 0644
inc.py File 2.25 KB 0644
indavideo.py File 4.31 KB 0644
infoq.py File 4.95 KB 0644
instagram.py File 16.21 KB 0644
internazionale.py File 3.25 KB 0644
internetvideoarchive.py File 2.36 KB 0644
iprima.py File 5.12 KB 0644
iqiyi.py File 13.31 KB 0644
ir90tv.py File 1.7 KB 0644
itv.py File 6.5 KB 0644
ivi.py File 10.2 KB 0644
ivideon.py File 3.18 KB 0644
iwara.py File 3.3 KB 0644
izlesene.py File 4.05 KB 0644
jamendo.py File 6.37 KB 0644
jeuxvideo.py File 1.99 KB 0644
joj.py File 3.66 KB 0644
jove.py File 3 KB 0644
jwplatform.py File 1.68 KB 0644
kakao.py File 5.38 KB 0644
kaltura.py File 15.03 KB 0644
kankan.py File 1.7 KB 0644
karaoketv.py File 2.29 KB 0644
karrierevideos.py File 3.3 KB 0644
keezmovies.py File 4.61 KB 0644
ketnet.py File 2.47 KB 0644
khanacademy.py File 3.83 KB 0644
kickstarter.py File 2.64 KB 0644
kinja.py File 8.37 KB 0644
kinopoisk.py File 2.17 KB 0644
konserthusetplay.py File 4.4 KB 0644
krasview.py File 1.91 KB 0644
ku6.py File 992 B 0644
kusi.py File 3.04 KB 0644
kuwo.py File 12.24 KB 0644
la7.py File 2.21 KB 0644
laola1tv.py File 9.23 KB 0644
lbry.py File 8.42 KB 0644
lci.py File 953 B 0644
lcp.py File 2.88 KB 0644
lecture2go.py File 2.35 KB 0644
lecturio.py File 8.24 KB 0644
leeco.py File 12.8 KB 0644
lego.py File 5.97 KB 0644
lemonde.py File 2.27 KB 0644
lenta.py File 1.64 KB 0644
libraryofcongress.py File 4.91 KB 0644
libsyn.py File 3.55 KB 0644
lifenews.py File 9.4 KB 0644
limelight.py File 14.54 KB 0644
line.py File 3.11 KB 0644
linkedin.py File 6.59 KB 0644
linuxacademy.py File 9.29 KB 0644
litv.py File 6.11 KB 0644
livejournal.py File 1.49 KB 0644
liveleak.py File 7.83 KB 0644
livestream.py File 13.38 KB 0644
lnkgo.py File 3.13 KB 0644
localnews8.py File 1.69 KB 0644
lovehomeporn.py File 1.16 KB 0644
lrt.py File 2.52 KB 0644
lynda.py File 12.41 KB 0644
m6.py File 896 B 0644
mailru.py File 11.26 KB 0644
malltv.py File 3.22 KB 0644
mangomolo.py File 1.98 KB 0644
manyvids.py File 3.05 KB 0644
markiza.py File 4.42 KB 0644
massengeschmacktv.py File 2.63 KB 0644
matchtv.py File 1.77 KB 0644
mdr.py File 6.9 KB 0644
medaltv.py File 4.55 KB 0644
medialaan.py File 9.76 KB 0644
mediaset.py File 7.65 KB 0644
mediasite.py File 14.33 KB 0644
medici.py File 2.24 KB 0644
megaphone.py File 1.73 KB 0644
meipai.py File 3.62 KB 0644
melonvod.py File 2.2 KB 0644
meta.py File 2.56 KB 0644
metacafe.py File 11.44 KB 0644
metacritic.py File 2.61 KB 0644
mgoon.py File 2.63 KB 0644
mgtv.py File 3.46 KB 0644
miaopai.py File 1.46 KB 0644
microsoftvirtualacademy.py File 7.3 KB 0644
minds.py File 6.75 KB 0644
ministrygrid.py File 2.12 KB 0644
minoto.py File 1.88 KB 0644
miomio.py File 4.95 KB 0644
mit.py File 5.09 KB 0644
mitele.py File 3.14 KB 0644
mixcloud.py File 11.39 KB 0644
mlb.py File 4.9 KB 0644
mnet.py File 2.86 KB 0644
moevideo.py File 2.77 KB 0644
mofosex.py File 2.69 KB 0644
mojvideo.py File 2.04 KB 0644
morningstar.py File 1.82 KB 0644
motherless.py File 8.68 KB 0644
motorsport.py File 1.76 KB 0644
movieclips.py File 1.85 KB 0644
moviezine.py File 1.37 KB 0644
movingimage.py File 1.73 KB 0644
msn.py File 7.41 KB 0644
mtv.py File 18.15 KB 0644
muenchentv.py File 2.08 KB 0644
mwave.py File 3.2 KB 0644
mychannels.py File 1.55 KB 0644
myspace.py File 8.21 KB 0644
myspass.py File 2.18 KB 0644
myvi.py File 3.92 KB 0644
myvidster.py File 918 B 0644
nationalgeographic.py File 2.86 KB 0644
naver.py File 6.44 KB 0644
nba.py File 16.28 KB 0644
nbc.py File 19.93 KB 0644
ndr.py File 15.88 KB 0644
ndtv.py File 4.5 KB 0644
nerdcubed.py File 1.1 KB 0644
neteasemusic.py File 16.93 KB 0644
netzkino.py File 2.98 KB 0644
newgrounds.py File 5.45 KB 0644
newstube.py File 3.05 KB 0644
nextmedia.py File 8.76 KB 0644
nexx.py File 16.71 KB 0644
nfl.py File 6.57 KB 0644
nhk.py File 6.54 KB 0644
nhl.py File 4.89 KB 0644
nick.py File 10.8 KB 0644
niconico.py File 19.88 KB 0644
ninecninemedia.py File 3.76 KB 0644
ninegag.py File 4 KB 0644
ninenow.py File 3.46 KB 0644
nintendo.py File 1.84 KB 0644
njpwworld.py File 3.36 KB 0644
nobelprize.py File 2.07 KB 0644
nonktube.py File 1.12 KB 0644
noovo.py File 3.57 KB 0644
normalboots.py File 2.13 KB 0644
nosvideo.py File 2.42 KB 0644
nova.py File 11.55 KB 0644
nowness.py File 5.88 KB 0644
noz.py File 3.58 KB 0644
npo.py File 27.53 KB 0644
npr.py File 4.94 KB 0644
nrk.py File 31.14 KB 0644
nrl.py File 1 KB 0644
ntvcojp.py File 1.89 KB 0644
ntvde.py File 3.12 KB 0644
ntvru.py File 4.94 KB 0644
nuevo.py File 1.18 KB 0644
nuvid.py File 2.53 KB 0644
nytimes.py File 10.03 KB 0644
nzz.py File 1.38 KB 0644
odatv.py File 1.46 KB 0644
odnoklassniki.py File 9.27 KB 0644
oktoberfesttv.py File 1.47 KB 0644
once.py File 2.12 KB 0644
ondemandkorea.py File 1.99 KB 0644
onet.py File 9.94 KB 0644
onionstudios.py File 1.89 KB 0644
ooyala.py File 8.57 KB 0644
openload.py File 7.99 KB 0644
ora.py File 3.15 KB 0644
orf.py File 19.26 KB 0644
outsidetv.py File 995 B 0644
packtpub.py File 6.18 KB 0644
pandoratv.py File 4.69 KB 0644
parliamentliveuk.py File 1.6 KB 0644
patreon.py File 5.51 KB 0644
pbs.py File 35.77 KB 0644
pearvideo.py File 2.05 KB 0644
peertube.py File 27.71 KB 0644
people.py File 1.11 KB 0644
performgroup.py File 3.28 KB 0644
periscope.py File 6.81 KB 0644
philharmoniedeparis.py File 3.67 KB 0644
phoenix.py File 1.47 KB 0644
photobucket.py File 1.75 KB 0644
picarto.py File 5.08 KB 0644
piksel.py File 6.88 KB 0644
pinkbike.py File 3.37 KB 0644
pinterest.py File 7.34 KB 0644
pladform.py File 4.14 KB 0644
platzi.py File 7.45 KB 0644
playfm.py File 2.54 KB 0644
playplustv.py File 3.64 KB 0644
plays.py File 1.8 KB 0644
playtvak.py File 7.1 KB 0644
playvid.py File 3.22 KB 0644
playwire.py File 2.35 KB 0644
pluralsight.py File 18.22 KB 0644
podomatic.py File 2.58 KB 0644
pokemon.py File 2.81 KB 0644
polskieradio.py File 6.51 KB 0644
popcorntimes.py File 3.28 KB 0644
popcorntv.py File 2.62 KB 0644
porn91.py File 2.07 KB 0644
porncom.py File 3.78 KB 0644
pornhd.py File 4.53 KB 0644
pornhub.py File 23.06 KB 0644
pornotube.py File 3.08 KB 0644
pornovoisines.py File 3.91 KB 0644
pornoxo.py File 1.89 KB 0644
presstv.py File 2.33 KB 0644
prosiebensat1.py File 21.07 KB 0644
puhutv.py File 8.26 KB 0644
puls4.py File 2.24 KB 0644
pyvideo.py File 2.7 KB 0644
qqmusic.py File 13.33 KB 0644
r7.py File 4.49 KB 0644
radiobremen.py File 2.37 KB 0644
radiocanada.py File 6.2 KB 0644
radiode.py File 1.78 KB 0644
radiofrance.py File 2.04 KB 0644
radiojavan.py File 2.7 KB 0644
rai.py File 17.82 KB 0644
raywenderlich.py File 6.02 KB 0644
rbmaradio.py File 2.35 KB 0644
rds.py File 2.73 KB 0644
redbulltv.py File 9.05 KB 0644
reddit.py File 5.21 KB 0644
redtube.py File 5.11 KB 0644
regiotv.py File 2.21 KB 0644
rentv.py File 4.06 KB 0644
restudy.py File 1.32 KB 0644
reuters.py File 2.38 KB 0644
reverbnation.py File 1.59 KB 0644
rice.py File 4.47 KB 0644
rmcdecouverte.py File 1.97 KB 0644
ro220.py File 1.42 KB 0644
rockstargames.py File 2.2 KB 0644
roosterteeth.py File 5.64 KB 0644
rottentomatoes.py File 1.25 KB 0644
roxwel.py File 1.92 KB 0644
rozhlas.py File 1.86 KB 0644
rtbf.py File 5.43 KB 0644
rte.py File 6.14 KB 0644
rtl2.py File 7.23 KB 0644
rtlnl.py File 5.76 KB 0644
rtp.py File 2.2 KB 0644
rts.py File 8.94 KB 0644
rtve.py File 9.83 KB 0644
rtvnh.py File 2.21 KB 0644
rtvs.py File 1.44 KB 0644
ruhd.py File 1.55 KB 0644
rumble.py File 2.13 KB 0644
rutube.py File 11.2 KB 0644
rutv.py File 7.88 KB 0644
ruutu.py File 9.13 KB 0644
ruv.py File 3.28 KB 0644
safari.py File 9.52 KB 0644
sapo.py File 4.39 KB 0644
savefrom.py File 1.06 KB 0644
sbs.py File 3.04 KB 0644
screencast.py File 4.57 KB 0644
screencastomatic.py File 1.32 KB 0644
scrippsnetworks.py File 5.5 KB 0644
scte.py File 4.88 KB 0644
seeker.py File 2.25 KB 0644
senateisvp.py File 6.13 KB 0644
sendtonews.py File 3.74 KB 0644
servus.py File 5.53 KB 0644
sevenplus.py File 3.23 KB 0644
sexu.py File 1.95 KB 0644
seznamzpravy.py File 7.73 KB 0644
shahid.py File 7.77 KB 0644
shared.py File 4.19 KB 0644
showroomlive.py File 3.05 KB 0644
sina.py File 4.22 KB 0644
sixplay.py File 5.13 KB 0644
sky.py File 5.29 KB 0644
skyit.py File 8.73 KB 0644
skylinewebcams.py File 1.42 KB 0644
skynewsarabia.py File 5.26 KB 0644
slideshare.py File 2.08 KB 0644
slideslive.py File 4.13 KB 0644
slutload.py File 2.29 KB 0644
snotr.py File 2.44 KB 0644
sohu.py File 6.75 KB 0644
sonyliv.py File 4.36 KB 0644
soundcloud.py File 29.37 KB 0644
soundgasm.py File 2.36 KB 0644
southpark.py File 4.58 KB 0644
spankbang.py File 7.06 KB 0644
spankwire.py File 6.32 KB 0644
spiegel.py File 2.33 KB 0644
spike.py File 1.66 KB 0644
sport5.py File 3.18 KB 0644
sportbox.py File 3.34 KB 0644
sportdeutschland.py File 2.89 KB 0644
spotify.py File 5.6 KB 0644
spreaker.py File 5.89 KB 0644
springboardplatform.py File 4.14 KB 0644
sprout.py File 2.27 KB 0644
srgssr.py File 8.07 KB 0644
srmediathek.py File 2.27 KB 0644
stanfordoc.py File 3.45 KB 0644
steam.py File 5.51 KB 0644
stitcher.py File 5.25 KB 0644
streamable.py File 3.8 KB 0644
streamcloud.py File 2.5 KB 0644
streamcz.py File 3.42 KB 0644
streetvoice.py File 3.54 KB 0644
stretchinternet.py File 1.02 KB 0644
stv.py File 3.37 KB 0644
sunporno.py File 2.59 KB 0644
sverigesradio.py File 3.82 KB 0644
svt.py File 14.34 KB 0644
swrmediathek.py File 4.27 KB 0644
syfy.py File 2 KB 0644
sztvhu.py File 1.63 KB 0644
tagesschau.py File 11.92 KB 0644
tass.py File 1.97 KB 0644
tbs.py File 3.31 KB 0644
tdslifeway.py File 2.42 KB 0644
teachable.py File 10.25 KB 0644
teachertube.py File 4.31 KB 0644
teachingchannel.py File 1.04 KB 0644
teamcoco.py File 7.14 KB 0644
teamtreehouse.py File 5.38 KB 0644
techtalks.py File 2.47 KB 0644
ted.py File 13.38 KB 0644
tele13.py File 3.27 KB 0644
tele5.py File 3.63 KB 0644
telebruxelles.py File 2.88 KB 0644
telecinco.py File 6.08 KB 0644
telegraaf.py File 2.92 KB 0644
telemb.py File 2.9 KB 0644
telequebec.py File 9.09 KB 0644
teletask.py File 1.7 KB 0644
telewebion.py File 1.8 KB 0644
tennistv.py File 3.85 KB 0644
tenplay.py File 2.91 KB 0644
testurl.py File 2.06 KB 0644
tf1.py File 3.53 KB 0644
tfo.py File 1.99 KB 0644
theintercept.py File 1.76 KB 0644
theplatform.py File 17.13 KB 0644
thescene.py File 1.34 KB 0644
thestar.py File 1.37 KB 0644
thesun.py File 1.37 KB 0644
theweatherchannel.py File 3.92 KB 0644
thisamericanlife.py File 1.51 KB 0644
thisav.py File 2.47 KB 0644
thisoldhouse.py File 1.96 KB 0644
threeqsdn.py File 6.11 KB 0644
tiktok.py File 4.69 KB 0644
tinypic.py File 1.85 KB 0644
tmz.py File 2.09 KB 0644
tnaflix.py File 11.93 KB 0644
toggle.py File 8.76 KB 0644
tonline.py File 2.04 KB 0644
toongoggles.py File 2.97 KB 0644
toutv.py File 3.47 KB 0644
toypics.py File 2.68 KB 0644
traileraddict.py File 2.63 KB 0644
trilulilu.py File 3.54 KB 0644
trovo.py File 6.09 KB 0644
trunews.py File 1.45 KB 0644
trutv.py File 2.47 KB 0644
tube8.py File 3.01 KB 0644
tubitv.py File 3.67 KB 0644
tudou.py File 1.66 KB 0644
tumblr.py File 7.54 KB 0644
tunein.py File 5.79 KB 0644
tunepk.py File 3.13 KB 0644
turbo.py File 2.37 KB 0644
turner.py File 10.85 KB 0644
tv2.py File 7.32 KB 0644
tv2dk.py File 5.11 KB 0644
tv2hu.py File 2.35 KB 0644
tv4.py File 4.29 KB 0644
tv5mondeplus.py File 4.39 KB 0644
tv5unis.py File 3.99 KB 0644
tva.py File 3.08 KB 0644
tvanouvelles.py File 2.34 KB 0644
tvc.py File 3.82 KB 0644
tver.py File 2.19 KB 0644
tvigle.py File 4.93 KB 0644
tvland.py File 1.43 KB 0644
tvn24.py File 3.81 KB 0644
tvnet.py File 4.83 KB 0644
tvnoe.py File 1.57 KB 0644
tvnow.py File 18.04 KB 0644
tvp.py File 9.2 KB 0644
tvplay.py File 17.75 KB 0644
tvplayer.py File 2.76 KB 0644
tweakers.py File 2.11 KB 0644
twentyfourvideo.py File 4.64 KB 0644
twentymin.py File 2.79 KB 0644
twentythreevideo.py File 3.22 KB 0644
twitcasting.py File 4.05 KB 0644
twitch.py File 32.69 KB 0644
twitter.py File 27.28 KB 0644
udemy.py File 18.96 KB 0644
udn.py File 3.49 KB 0644
ufctv.py File 511 B 0644
uktvplay.py File 1.33 KB 0644
umg.py File 3.33 KB 0644
unistra.py File 2.11 KB 0644
unity.py File 1.2 KB 0644
uol.py File 5.41 KB 0644
uplynk.py File 2.56 KB 0644
urort.py File 2.2 KB 0644
urplay.py File 3.76 KB 0644
usanetwork.py File 795 B 0644
usatoday.py File 2.64 KB 0644
ustream.py File 10.51 KB 0644
ustudio.py File 4.29 KB 0644
varzesh3.py File 3.16 KB 0644
vbox7.py File 3.33 KB 0644
veehd.py File 4.04 KB 0644
veoh.py File 3.9 KB 0644
vesti.py File 4.28 KB 0644
vevo.py File 13.8 KB 0644
vgtv.py File 10.36 KB 0644
vh1.py File 1.5 KB 0644
vice.py File 12.12 KB 0644
vidbit.py File 2.85 KB 0644
viddler.py File 4.78 KB 0644
videa.py File 5.67 KB 0644
videodetective.py File 906 B 0644
videofyme.py File 1.71 KB 0644
videomore.py File 11.46 KB 0644
videopress.py File 2.94 KB 0644
vidio.py File 2.79 KB 0644
vidlii.py File 4.42 KB 0644
vidme.py File 9.66 KB 0644
vidzi.py File 2.11 KB 0644
vier.py File 9.77 KB 0644
viewlift.py File 9.76 KB 0644
viidea.py File 7.27 KB 0644
viki.py File 14.43 KB 0644
vimeo.py File 45.68 KB 0644
vimple.py File 1.92 KB 0644
vine.py File 5.2 KB 0644
viqeo.py File 3.22 KB 0644
viu.py File 9.05 KB 0644
vk.py File 25.26 KB 0644
vlive.py File 11.6 KB 0644
vodlocker.py File 2.73 KB 0644
vodpl.py File 1.01 KB 0644
vodplatform.py File 1.53 KB 0644
voicerepublic.py File 2.25 KB 0644
voot.py File 3.48 KB 0644
voxmedia.py File 9.07 KB 0644
vrak.py File 2.87 KB 0644
vrt.py File 3.44 KB 0644
vrv.py File 10.85 KB 0644
vshare.py File 2.23 KB 0644
vube.py File 6.77 KB 0644
vuclip.py File 2.2 KB 0644
vvvvid.py File 8.62 KB 0644
vyborymos.py File 1.98 KB 0644
vzaar.py File 3.53 KB 0644
wakanim.py File 2.32 KB 0644
walla.py File 2.75 KB 0644
washingtonpost.py File 5.13 KB 0644
wat.py File 4.53 KB 0644
watchbox.py File 5.8 KB 0644
watchindianporn.py File 2.24 KB 0644
wdr.py File 12.92 KB 0644
webcaster.py File 3.74 KB 0644
webofstories.py File 5.42 KB 0644
weibo.py File 4.39 KB 0644
weiqitv.py File 1.64 KB 0644
wistia.py File 7.06 KB 0644
worldstarhiphop.py File 1.31 KB 0644
wsj.py File 4.58 KB 0644
wwe.py File 4.43 KB 0644
xbef.py File 1.41 KB 0644
xboxclips.py File 1.9 KB 0644
xfileshare.py File 7.08 KB 0644
xhamster.py File 14.95 KB 0644
xiami.py File 6.66 KB 0644
ximalaya.py File 9.68 KB 0644
xminus.py File 2.87 KB 0644
xnxx.py File 2.82 KB 0644
xstream.py File 3.89 KB 0644
xtube.py File 6.98 KB 0644
xuite.py File 5.67 KB 0644
xvideos.py File 5.16 KB 0644
xxxymovies.py File 2.61 KB 0644
yahoo.py File 22.33 KB 0644
yandexdisk.py File 5.04 KB 0644
yandexmusic.py File 16.71 KB 0644
yandexvideo.py File 5.13 KB 0644
yapfiles.py File 3.14 KB 0644
yesjapan.py File 2.14 KB 0644
yinyuetai.py File 1.86 KB 0644
ynet.py File 1.76 KB 0644
youjizz.py File 3.05 KB 0644
youku.py File 11.14 KB 0644
younow.py File 6.92 KB 0644
youporn.py File 8.2 KB 0644
yourporn.py File 2.01 KB 0644
yourupload.py File 1.38 KB 0644
youtube.py File 158.61 KB 0644
zapiks.py File 3.74 KB 0644
zattoo.py File 13.99 KB 0644
zdf.py File 11.66 KB 0644
zingmp3.py File 4.71 KB 0644
zype.py File 5.43 KB 0644