import itertools
import struct
import time
-import urllib.error
import urllib.parse
from .fragment import FragmentFD
from ..compat import compat_etree_fromstring
+from ..networking.exceptions import HTTPError
from ..utils import fix_xml_ampersands, xpath_text
self.read_bytes(3)
quality_entry_count = self.read_unsigned_char()
# QualityEntryCount
- for i in range(quality_entry_count):
+ for _ in range(quality_entry_count):
self.read_string()
segment_run_count = self.read_unsigned_int()
segments = []
- for i in range(segment_run_count):
+ for _ in range(segment_run_count):
first_segment = self.read_unsigned_int()
fragments_per_segment = self.read_unsigned_int()
segments.append((first_segment, fragments_per_segment))
quality_entry_count = self.read_unsigned_char()
# QualitySegmentUrlModifiers
- for i in range(quality_entry_count):
+ for _ in range(quality_entry_count):
self.read_string()
fragments_count = self.read_unsigned_int()
fragments = []
- for i in range(fragments_count):
+ for _ in range(fragments_count):
first = self.read_unsigned_int()
first_ts = self.read_unsigned_long_long()
duration = self.read_unsigned_int()
self.read_string() # MovieIdentifier
server_count = self.read_unsigned_char()
# ServerEntryTable
- for i in range(server_count):
+ for _ in range(server_count):
self.read_string()
quality_count = self.read_unsigned_char()
# QualityEntryTable
- for i in range(quality_count):
+ for _ in range(quality_count):
self.read_string()
# DrmData
self.read_string()
segments_count = self.read_unsigned_char()
segments = []
- for i in range(segments_count):
+ for _ in range(segments_count):
box_size, box_type, box_data = self.read_box_info()
assert box_type == b'asrt'
segment = FlvReader(box_data).read_asrt()
segments.append(segment)
fragments_run_count = self.read_unsigned_char()
fragments = []
- for i in range(fragments_run_count):
+ for _ in range(fragments_run_count):
box_size, box_type, box_data = self.read_box_info()
assert box_type == b'afrt'
fragments.append(FlvReader(box_data).read_afrt())
first_frag_number = fragment_run_entry_table[0]['first']
fragments_counter = itertools.count(first_frag_number)
for segment, fragments_count in segment_run_table['segment_run']:
- # In some live HDS streams (for example Rai), `fragments_count` is
+ # In some live HDS streams (e.g. Rai), `fragments_count` is
# abnormal and causing out-of-memory errors. It's OK to change the
# number of fragments for live streams as they are updated periodically
if fragments_count == 4294967295 and boot_info['live']:
def real_download(self, filename, info_dict):
man_url = info_dict['url']
requested_bitrate = info_dict.get('tbr')
- self.to_screen('[%s] Downloading f4m manifest' % self.FD_NAME)
+ self.to_screen(f'[{self.FD_NAME}] Downloading f4m manifest')
urlh = self.ydl.urlopen(self._prepare_url(info_dict, man_url))
- man_url = urlh.geturl()
+ man_url = urlh.url
# Some manifests may be malformed, e.g. prosiebensat1 generated manifests
# (see https://github.com/ytdl-org/youtube-dl/issues/6215#issuecomment-121704244
# and https://github.com/ytdl-org/youtube-dl/issues/7823)
formats = sorted(formats, key=lambda f: f[0])
rate, media = formats[-1]
else:
- rate, media = list(filter(
- lambda f: int(f[0]) == requested_bitrate, formats))[0]
+ rate, media = next(filter(
+ lambda f: int(f[0]) == requested_bitrate, formats))
# Prefer baseURL for relative URLs as per 11.2 of F4M 3.0 spec.
man_base_url = get_base_url(doc) or man_url
if box_type == b'mdat':
self._append_fragment(ctx, box_data)
break
- except urllib.error.HTTPError as err:
- if live and (err.code == 404 or err.code == 410):
+ except HTTPError as err:
+ if live and (err.status == 404 or err.status == 410):
# We didn't keep up with the live window. Continue
# with the next available fragment.
msg = 'Fragment %d unavailable' % frag_i
msg = 'Missed %d fragments' % (fragments_list[0][1] - (frag_i + 1))
self.report_warning(msg)
- self._finish_frag_download(ctx, info_dict)
-
- return True
+ return self._finish_frag_download(ctx, info_dict)