parse_iso8601,
parse_resolution,
parse_bitrate,
+ parse_qs,
pkcs1pad,
read_batch_urls,
sanitize_filename,
compat_getenv,
compat_os_name,
compat_setenv,
- compat_urlparse,
- compat_parse_qs,
)
self.assertTrue(isinstance(data, bytes))
def test_update_url_query(self):
- def query_dict(url):
- return compat_parse_qs(compat_urlparse.urlparse(url).query)
- self.assertEqual(query_dict(update_url_query(
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'quality': ['HD'], 'format': ['mp4']})),
- query_dict('http://example.com/path?quality=HD&format=mp4'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?quality=HD&format=mp4'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'system': ['LINUX', 'WINDOWS']})),
- query_dict('http://example.com/path?system=LINUX&system=WINDOWS'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?system=LINUX&system=WINDOWS'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'fields': 'id,formats,subtitles'})),
- query_dict('http://example.com/path?fields=id,formats,subtitles'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?fields=id,formats,subtitles'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'fields': ('id,formats,subtitles', 'thumbnails')})),
- query_dict('http://example.com/path?fields=id,formats,subtitles&fields=thumbnails'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?fields=id,formats,subtitles&fields=thumbnails'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path?manifest=f4m', {'manifest': []})),
- query_dict('http://example.com/path'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path?system=LINUX&system=WINDOWS', {'system': 'LINUX'})),
- query_dict('http://example.com/path?system=LINUX'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?system=LINUX'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'fields': b'id,formats,subtitles'})),
- query_dict('http://example.com/path?fields=id,formats,subtitles'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?fields=id,formats,subtitles'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'width': 1080, 'height': 720})),
- query_dict('http://example.com/path?width=1080&height=720'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?width=1080&height=720'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'bitrate': 5020.43})),
- query_dict('http://example.com/path?bitrate=5020.43'))
- self.assertEqual(query_dict(update_url_query(
+ parse_qs('http://example.com/path?bitrate=5020.43'))
+ self.assertEqual(parse_qs(update_url_query(
'http://example.com/path', {'test': '第二行тест'})),
- query_dict('http://example.com/path?test=%E7%AC%AC%E4%BA%8C%E8%A1%8C%D1%82%D0%B5%D1%81%D1%82'))
+ parse_qs('http://example.com/path?test=%E7%AC%AC%E4%BA%8C%E8%A1%8C%D1%82%D0%B5%D1%81%D1%82'))
def test_multipart_encode(self):
self.assertEqual(
import re
from .yahoo import YahooIE
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
ExtractorError,
int_or_none,
+ parse_qs,
url_or_none,
)
'height': int(mobj.group(2)),
})
else:
- qs = compat_parse_qs(compat_urllib_parse_urlparse(video_url).query)
+ qs = parse_qs(video_url)
f.update({
'width': int_or_none(qs.get('w', [None])[0]),
'height': int_or_none(qs.get('h', [None])[0]),
from ..compat import (
compat_urllib_parse_unquote,
compat_urllib_parse_unquote_plus,
- compat_urlparse,
- compat_parse_qs,
compat_HTTPError
)
from ..utils import (
merge_dicts,
mimetype2ext,
parse_duration,
+ parse_qs,
RegexNotFoundError,
str_to_int,
str_or_none,
expected=True)
raise
video_file_url = compat_urllib_parse_unquote(video_file_webpage.url)
- video_file_url_qs = compat_parse_qs(compat_urlparse.urlparse(video_file_url).query)
+ video_file_url_qs = parse_qs(video_file_url)
# Attempt to recover any ext & format info from playback url
format = {'url': video_file_url}
import re
from .common import InfoExtractor
-from ..compat import compat_urlparse
from ..utils import (
ExtractorError,
float_or_none,
int_or_none,
parse_iso8601,
+ parse_qs,
try_get,
)
# Handle http://video.arkena.com/play2/embed/player URL
if not video_id:
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
video_id = qs.get('mediaId', [None])[0]
account_id = qs.get('accountId', [None])[0]
if not video_id or not account_id:
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
)
from ..utils import (
ExtractorError,
int_or_none,
+ parse_qs,
qualities,
try_get,
unified_strdate,
webpage)]
def _real_extract(self, url):
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
json_url = qs['json_url'][0]
video_id = ArteTVIE._match_id(json_url)
return self.url_result(
from ..compat import (
compat_etree_Element,
compat_HTTPError,
- compat_parse_qs,
compat_str,
- compat_urllib_parse_urlparse,
compat_urlparse,
)
from ..utils import (
js_to_json,
parse_duration,
parse_iso8601,
+ parse_qs,
strip_or_none,
try_get,
unescapeHTML,
def _real_extract(self, url):
pid = self._match_id(url)
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
series_id = qs.get('seriesId', [None])[0]
page = qs.get('page', [None])[0]
per_page = 36 if page else self._PAGE_SIZE
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
)
from ..utils import (
int_or_none,
+ parse_qs,
unified_timestamp,
)
query = {
'v': 2,
}
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
t = qs.get('t', [''])[0].split('-')
if len(t) > 1:
query.update({
compat_etree_fromstring,
compat_HTTPError,
compat_parse_qs,
- compat_urllib_parse_urlparse,
compat_urlparse,
compat_xml_parse_error,
)
js_to_json,
mimetype2ext,
parse_iso8601,
+ parse_qs,
smuggle_url,
str_or_none,
try_get,
flashvars = {}
data_url = object_doc.attrib.get('data', '')
- data_url_params = compat_parse_qs(compat_urllib_parse_urlparse(data_url).query)
+ data_url_params = parse_qs(data_url)
def find_param(name):
if name in flashvars:
import itertools
from .common import InfoExtractor
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
clean_html,
float_or_none,
int_or_none,
+ parse_qs,
try_get,
urlencode_postdata,
)
query['from'] += query['size']
def _real_extract(self, url):
- query = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ query = parse_qs(url)
query['type'] = 'session'
return self.playlist_result(
self._entries(query, url), playlist_title='Search query')
from __future__ import unicode_literals
from .common import InfoExtractor
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
float_or_none,
+ parse_qs,
unified_timestamp,
)
def _real_extract(self, url):
audio_id = self._match_id(url)
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
token = qs.get('token', [None])[0]
query = {}
from .common import InfoExtractor
from ..compat import (
- compat_parse_qs,
compat_urllib_parse_unquote,
- compat_urlparse,
)
+from ..utils import parse_qs
class DaumBaseIE(InfoExtractor):
return name, entries
def _check_clip(self, url, list_id):
- query_dict = compat_parse_qs(compat_urlparse.urlparse(url).query)
+ query_dict = parse_qs(url)
if 'clipid' in query_dict:
clip_id = query_dict['clipid'][0]
if self.get_param('noplaylist'):
if clip_result:
return clip_result
- query_dict = compat_parse_qs(compat_urlparse.urlparse(url).query)
+ query_dict = parse_qs(url)
if 'playlistid' in query_dict:
playlist_id = query_dict['playlistid'][0]
return self.url_result(DaumPlaylistIE._URL_TEMPLATE % playlist_id, 'DaumPlaylist')
from __future__ import unicode_literals
from .common import InfoExtractor
-from ..compat import compat_urlparse
from ..utils import (
int_or_none,
orderedSet,
parse_duration,
+ parse_qs,
qualities,
unified_strdate,
xpath_text
if items.get(p):
return items[p]
- query = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ query = parse_qs(url)
preferred_lang = query.get('sitelang', ('en', ))[0]
preferred_langs = orderedSet((preferred_lang, 'en', 'int'))
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
)
from ..utils import (
clean_html,
ExtractorError,
int_or_none,
parse_duration,
+ parse_qs,
try_get,
url_or_none,
urljoin,
catalog = mobj.group('catalog')
if not video_id:
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
video_id = qs.get('idDiffusion', [None])[0]
catalog = qs.get('catalogue', [None])[0]
if not video_id:
import re
from .common import InfoExtractor
-from ..compat import (
- compat_parse_qs,
- compat_urlparse,
-)
+from ..utils import parse_qs
class InternetVideoArchiveIE(InfoExtractor):
return 'http://video.internetvideoarchive.net/player/6/configuration.ashx?' + query
def _real_extract(self, url):
- query = compat_parse_qs(compat_urlparse.urlparse(url).query)
+ query = parse_qs(url)
video_id = query['publishedid'][0]
data = self._download_json(
'https://video.internetvideoarchive.net/videojs7/videojs7.ivasettings.ashx',
from .common import InfoExtractor
from ..compat import (
- compat_parse_qs,
compat_str,
compat_urllib_parse_unquote,
- compat_urllib_parse_urlparse,
)
from ..utils import (
determine_ext,
ExtractorError,
int_or_none,
mimetype2ext,
+ parse_qs,
OnDemandPagedList,
try_get,
urljoin,
result = self._resolve_url(
'lbry://' + display_id, display_id, 'channel')
claim_id = result['claim_id']
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
content = qs.get('content', [None])[0]
params = {
'fee_amount': qs.get('fee_amount', ['>=0'])[0],
import re
from .theplatform import ThePlatformBaseIE
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
ExtractorError,
int_or_none,
+ parse_qs,
update_url_query,
)
@staticmethod
def _extract_urls(ie, webpage):
def _qs(url):
- return compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ return parse_qs(url)
def _program_guid(qs):
return qs.get('programGuid', [None])[0]
from .turner import TurnerBaseIE
from ..compat import (
- compat_parse_qs,
compat_str,
compat_urllib_parse_unquote,
- compat_urllib_parse_urlparse,
)
from ..utils import (
int_or_none,
OnDemandPagedList,
parse_duration,
parse_iso8601,
+ parse_qs,
try_get,
update_url_query,
urljoin,
def _real_extract(self, url):
display_id = self._match_id(url)
- collection_id = compat_parse_qs(compat_urllib_parse_urlparse(url).query).get('collection', [None])[0]
+ collection_id = parse_qs(url).get('collection', [None])[0]
if collection_id:
if self.get_param('noplaylist'):
self.to_screen('Downloading just video %s because of --no-playlist' % display_id)
}]
def _real_extract(self, url):
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
content_id = qs['contentId'][0]
team = qs.get('team', [None])[0]
if not team:
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
)
from ..utils import (
clean_html,
int_or_none,
float_or_none,
parse_iso8601,
+ parse_qs,
sanitized_Request,
urlencode_postdata,
)
webpage, 'noco player', group='player',
default='http://noco.tv/cdata/js/player/NocoPlayer-v1.2.40.swf')
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(player_url).query)
+ qs = parse_qs(player_url)
ts = int_or_none(qs.get('ts', [None])[0])
self._ts_offset = ts - self._ts() if ts else 0
self._referer = player_url
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
)
from ..utils import (
ExtractorError,
float_or_none,
parse_duration,
+ parse_qs,
str_to_int,
urlencode_postdata,
)
video_id = mobj.group('id')
if not user_id or not video_id:
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
video_id = qs.get('prgid', [None])[0]
user_id = qs.get('ch_userid', [None])[0]
if any(not f for f in (video_id, user_id,)):
import re
from .common import InfoExtractor
-from ..compat import compat_urlparse
from ..utils import (
determine_ext,
ExtractorError,
int_or_none,
+ parse_qs,
xpath_text,
qualities,
)
def _real_extract(self, url):
video_id = self._match_id(url)
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
pl = qs.get('pl', ['1'])[0]
video = self._download_xml(
float_or_none,
int_or_none,
parse_duration,
+ parse_qs,
qualities,
srt_subtitles_timecode,
try_get,
return srt
def _real_extract(self, url):
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
author = qs.get('author', [None])[0]
name = qs.get('name', [None])[0]
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_parse_qs,
- compat_urllib_parse_urlparse,
)
from ..utils import (
determine_ext,
bool_or_none,
int_or_none,
+ parse_qs,
try_get,
unified_timestamp,
url_or_none,
embed_id = self._match_id(url)
# Query may contain private videos token and should be passed to API
# requests (see #19163)
- query = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ query = parse_qs(url)
options = self._download_api_options(embed_id, query)
video_id = options['effective_video']
formats = self._extract_formats(options, video_id)
def suitable(cls, url):
if not super(RutubePlaylistIE, cls).suitable(url):
return False
- params = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ params = parse_qs(url)
return params.get('pl_type', [None])[0] and int_or_none(params.get('pl_id', [None])[0])
def _next_page_url(self, page_num, playlist_id, item_kind):
return self._PAGE_TEMPLATE % (item_kind, playlist_id, page_num)
def _real_extract(self, url):
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
playlist_kind = qs['pl_type'][0]
playlist_id = qs['pl_id'][0]
return self._extract_playlist(playlist_id, item_kind=playlist_kind)
from .common import InfoExtractor
from ..compat import (
- compat_parse_qs,
compat_str,
compat_urllib_parse_urlparse,
)
urljoin,
int_or_none,
parse_codecs,
+ parse_qs,
try_get,
)
return formats
def _real_extract(self, url):
- params = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ params = parse_qs(url)
src = params['src'][0]
title = params['title'][0]
from .common import InfoExtractor
from ..compat import (
- compat_parse_qs,
compat_str,
- compat_urllib_parse_urlparse,
)
from ..utils import (
determine_ext,
int_or_none,
+ parse_qs,
try_get,
qualities,
)
continue
if container == 'm3u8' or ext == 'm3u8':
if protocol == 'usp':
- if compat_parse_qs(compat_urllib_parse_urlparse(asset_url).query).get('token', [None])[0]:
+ if parse_qs(asset_url).get('token', [None])[0]:
urlh = self._request_webpage(
asset_url, video_id, fatal=False,
headers=self.geo_verification_headers())
from __future__ import unicode_literals
from .common import InfoExtractor
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
clean_html,
float_or_none,
int_or_none,
parse_iso8601,
+ parse_qs,
strip_or_none,
try_get,
)
}
videos = asset.get('videos') or []
if len(videos) > 1:
- playlist_id = compat_parse_qs(compat_urllib_parse_urlparse(url).query).get('playlistId', [None])[0]
+ playlist_id = parse_qs(url).get('playlistId', [None])[0]
if playlist_id:
if self.get_param('noplaylist'):
videos = [videos[int(playlist_id)]]
from .common import InfoExtractor
from .jwplatform import JWPlatformIE
from .nexx import NexxIE
-from ..compat import compat_urlparse
from ..utils import (
NO_DEFAULT,
+ parse_qs,
smuggle_url,
)
}]
def _real_extract(self, url):
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
video_id = (qs.get('vid') or qs.get('ve_id') or [None])[0]
NEXX_ID_RE = r'\d{6,}'
from .once import OnceIE
from .adobepass import AdobePassIE
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
determine_ext,
ExtractorError,
float_or_none,
int_or_none,
+ parse_qs,
sanitized_Request,
unsmuggle_url,
update_url_query,
path += mobj.group('media')
path += video_id
- qs_dict = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs_dict = parse_qs(url)
if 'guid' in qs_dict:
webpage = self._download_webpage(url, video_id)
scripts = re.findall(r'<script[^>]+src="([^"]+)"', webpage)
if first_video_id is None:
first_video_id = cur_video_id
duration = float_or_none(item.get('plfile$duration'))
- file_asset_types = item.get('plfile$assetTypes') or compat_parse_qs(compat_urllib_parse_urlparse(smil_url).query)['assetTypes']
+ file_asset_types = item.get('plfile$assetTypes') or parse_qs(smil_url)['assetTypes']
for asset_type in file_asset_types:
if asset_type in asset_types:
continue
from ..compat import (
compat_parse_qs,
compat_str,
- compat_urlparse,
compat_urllib_parse_urlencode,
compat_urllib_parse_urlparse,
)
int_or_none,
parse_duration,
parse_iso8601,
+ parse_qs,
qualities,
try_get,
unified_timestamp,
def _real_extract(self, url):
channel_name = self._match_id(url)
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
filter = qs.get('filter', ['all'])[0]
sort = qs.get('sort', ['time'])[0]
broadcast = self._BROADCASTS.get(filter, self._DEFAULT_BROADCAST)
def _real_extract(self, url):
channel_name = self._match_id(url)
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
range = qs.get('range', ['7d'])[0]
clip = self._RANGE.get(range, self._DEFAULT_CLIP)
return self.playlist_result(
from __future__ import unicode_literals
from .common import InfoExtractor
-from ..compat import (
- compat_urllib_parse_urlparse,
- compat_parse_qs,
-)
from ..utils import (
clean_html,
+ parse_qs,
remove_start,
)
fb_sharer_url = self._search_regex(
r'<a[^>]+href="(https?://www\.facebook\.com/sharer/sharer\.php?[^"]+)"',
webpage, 'facebook sharer URL', fatal=False)
- sharer_params = compat_parse_qs(compat_urllib_parse_urlparse(fb_sharer_url).query)
+ sharer_params = parse_qs(fb_sharer_url)
thumbnail = sharer_params.get('p[images][0]', [None])[0]
video_id = self._search_regex(
from .common import InfoExtractor
from ..compat import (
compat_str,
- compat_urlparse,
compat_HTTPError,
)
from ..utils import (
ExtractorError,
int_or_none,
parse_iso8601,
+ parse_qs,
)
webpage = self._download_webpage(url, playlist_id)
- qs = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
+ qs = parse_qs(url)
index = qs.get('index', [None])[0]
if index:
int_or_none,
mimetype2ext,
parse_codecs,
+ parse_qs,
update_url_query,
urljoin,
xpath_element,
compat_b64decode,
compat_ord,
compat_struct_pack,
- compat_urlparse,
)
for i in range(0, 32):
result += s[i - (self._STATIC_SECRET.index(l[i]) - 31)]
- query = compat_urlparse.parse_qs(compat_urlparse.urlparse(player_url).query)
+ query = parse_qs(player_url)
random_seed = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
query['_s'] = random_seed
query['_t'] = result[:16]
from .common import InfoExtractor
from ..compat import (
- compat_parse_qs,
compat_str,
- compat_urllib_parse_urlparse,
)
from ..utils import (
int_or_none,
+ parse_qs,
)
def _real_extract(self, url):
mobj = self._match_valid_url(url)
video_id = mobj.group('sid') or mobj.group('id')
- partner_id = mobj.group('partner_id') or compat_parse_qs(compat_urllib_parse_urlparse(url).query).get('partner_id', [None])[0] or '97'
+ partner_id = mobj.group('partner_id') or parse_qs(url).get('partner_id', [None])[0] or '97'
item = self._download_json(
'https://siren.more.tv/player/config', video_id, query={
OnDemandPagedList,
parse_filesize,
parse_iso8601,
+ parse_qs,
RegexNotFoundError,
sanitized_Request,
smuggle_url,
download_url = download_data.get('link')
if not download_url or download_data.get('quality') != 'source':
continue
- query = compat_urlparse.parse_qs(compat_urlparse.urlparse(download_url).query)
+ query = parse_qs(download_url)
return {
'url': download_url,
'ext': determine_ext(query.get('filename', [''])[0].lower()),
import re
from .common import InfoExtractor
-from ..compat import (
- compat_parse_qs,
- compat_urllib_parse_urlparse,
-)
from ..utils import (
int_or_none,
month_by_abbreviation,
parse_filesize,
+ parse_qs,
)
video_id = self._match_id(url)
if '/video.php' in url:
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
url = 'https://gameclips.io/%s/%s' % (qs['gamertag'][0], qs['vid'][0])
webpage = self._download_webpage(url, video_id)
parse_count,
parse_duration,
parse_iso8601,
+ parse_qs,
qualities,
remove_start,
smuggle_url,
)
-def parse_qs(url):
- return compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
-
-
# any clients starting with _ cannot be explicity requested by the user
INNERTUBE_CLIENTS = {
'web': {
def suitable(cls, url):
# Hack for lazy extractors until more generic solution is implemented
# (see #28780)
- from .youtube import parse_qs
+ from ..utils import parse_qs
+
qs = parse_qs(url)
if qs.get('list', [None])[0]:
return False
return cls._VALID_URL
def _real_extract(self, url):
- qs = compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+ qs = parse_qs(url)
query = (qs.get('search_query') or qs.get('q'))[0]
self._SEARCH_PARAMS = qs.get('sp', ('',))[0]
return self._get_n_results(query, self._MAX_RESULTS)
).geturl()
+def parse_qs(url):
+ return compat_parse_qs(compat_urllib_parse_urlparse(url).query)
+
+
def read_batch_urls(batch_fd):
def fixup(url):
if not isinstance(url, compat_str):
projects / yt-dlp.git / commitdiff
