@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/downloader/http.py

@@ -1,383 +0,0 @@
-import os
-import random
-import time
-
-from .common import FileDownloader
-from ..networking import Request
-from ..networking.exceptions import (
-    CertificateVerifyError,
-    HTTPError,
-    TransportError,
-)
-from ..utils import (
-    ContentTooShortError,
-    RetryManager,
-    ThrottledDownload,
-    XAttrMetadataError,
-    XAttrUnavailableError,
-    encodeFilename,
-    int_or_none,
-    parse_http_range,
-    try_call,
-    write_xattr,
-)
-from ..utils.networking import HTTPHeaderDict
-
-
-class HttpFD(FileDownloader):
-    def real_download(self, filename, info_dict):
-        url = info_dict['url']
-        request_data = info_dict.get('request_data', None)
-
-        class DownloadContext(dict):
-            __getattr__ = dict.get
-            __setattr__ = dict.__setitem__
-            __delattr__ = dict.__delitem__
-
-        ctx = DownloadContext()
-        ctx.filename = filename
-        ctx.tmpfilename = self.temp_name(filename)
-        ctx.stream = None
-
-        # Disable compression
-        headers = HTTPHeaderDict({'Accept-Encoding': 'identity'}, info_dict.get('http_headers'))
-
-        is_test = self.params.get('test', False)
-        chunk_size = self._TEST_FILE_SIZE if is_test else (
-            self.params.get('http_chunk_size')
-            or info_dict.get('downloader_options', {}).get('http_chunk_size')
-            or 0)
-
-        ctx.open_mode = 'wb'
-        ctx.resume_len = 0
-        ctx.block_size = self.params.get('buffersize', 1024)
-        ctx.start_time = time.time()
-
-        # parse given Range
-        req_start, req_end, _ = parse_http_range(headers.get('Range'))
-
-        if self.params.get('continuedl', True):
-            # Establish possible resume length
-            if os.path.isfile(encodeFilename(ctx.tmpfilename)):
-                ctx.resume_len = os.path.getsize(
-                    encodeFilename(ctx.tmpfilename))
-
-        ctx.is_resume = ctx.resume_len > 0
-
-        class SucceedDownload(Exception):
-            pass
-
-        class RetryDownload(Exception):
-            def __init__(self, source_error):
-                self.source_error = source_error
-
-        class NextFragment(Exception):
-            pass
-
-        def establish_connection():
-            ctx.chunk_size = (random.randint(int(chunk_size * 0.95), chunk_size)
-                              if not is_test and chunk_size else chunk_size)
-            if ctx.resume_len > 0:
-                range_start = ctx.resume_len
-                if req_start is not None:
-                    # offset the beginning of Range to be within request
-                    range_start += req_start
-                if ctx.is_resume:
-                    self.report_resuming_byte(ctx.resume_len)
-                ctx.open_mode = 'ab'
-            elif req_start is not None:
-                range_start = req_start
-            elif ctx.chunk_size > 0:
-                range_start = 0
-            else:
-                range_start = None
-            ctx.is_resume = False
-
-            if ctx.chunk_size:
-                chunk_aware_end = range_start + ctx.chunk_size - 1
-                # we're not allowed to download outside Range
-                range_end = chunk_aware_end if req_end is None else min(chunk_aware_end, req_end)
-            elif req_end is not None:
-                # there's no need for chunked downloads, so download until the end of Range
-                range_end = req_end
-            else:
-                range_end = None
-
-            if try_call(lambda: range_start > range_end):
-                ctx.resume_len = 0
-                ctx.open_mode = 'wb'
-                raise RetryDownload(Exception(f'Conflicting range. (start={range_start} > end={range_end})'))
-
-            if try_call(lambda: range_end >= ctx.content_len):
-                range_end = ctx.content_len - 1
-
-            request = Request(url, request_data, headers)
-            has_range = range_start is not None
-            if has_range:
-                request.headers['Range'] = f'bytes={int(range_start)}-{int_or_none(range_end) or ""}'
-            # Establish connection
-            try:
-                ctx.data = self.ydl.urlopen(request)
-                # When trying to resume, Content-Range HTTP header of response has to be checked
-                # to match the value of requested Range HTTP header. This is due to a webservers
-                # that don't support resuming and serve a whole file with no Content-Range
-                # set in response despite of requested Range (see
-                # https://github.com/ytdl-org/youtube-dl/issues/6057#issuecomment-126129799)
-                if has_range:
-                    content_range = ctx.data.headers.get('Content-Range')
-                    content_range_start, content_range_end, content_len = parse_http_range(content_range)
-                    # Content-Range is present and matches requested Range, resume is possible
-                    if range_start == content_range_start and (
-                            # Non-chunked download
-                            not ctx.chunk_size
-                            # Chunked download and requested piece or
-                            # its part is promised to be served
-                            or content_range_end == range_end
-                            or content_len < range_end):
-                        ctx.content_len = content_len
-                        if content_len or req_end:
-                            ctx.data_len = min(content_len or req_end, req_end or content_len) - (req_start or 0)
-                        return
-                    # Content-Range is either not present or invalid. Assuming remote webserver is
-                    # trying to send the whole file, resume is not possible, so wiping the local file
-                    # and performing entire redownload
-                    elif range_start > 0:
-                        self.report_unable_to_resume()
-                    ctx.resume_len = 0
-                    ctx.open_mode = 'wb'
-                ctx.data_len = ctx.content_len = int_or_none(ctx.data.headers.get('Content-length', None))
-            except HTTPError as err:
-                if err.status == 416:
-                    # Unable to resume (requested range not satisfiable)
-                    try:
-                        # Open the connection again without the range header
-                        ctx.data = self.ydl.urlopen(
-                            Request(url, request_data, headers))
-                        content_length = ctx.data.headers['Content-Length']
-                    except HTTPError as err:
-                        if err.status < 500 or err.status >= 600:
-                            raise
-                    else:
-                        # Examine the reported length
-                        if (content_length is not None
-                                and (ctx.resume_len - 100 < int(content_length) < ctx.resume_len + 100)):
-                            # The file had already been fully downloaded.
-                            # Explanation to the above condition: in issue #175 it was revealed that
-                            # YouTube sometimes adds or removes a few bytes from the end of the file,
-                            # changing the file size slightly and causing problems for some users. So
-                            # I decided to implement a suggested change and consider the file
-                            # completely downloaded if the file size differs less than 100 bytes from
-                            # the one in the hard drive.
-                            self.report_file_already_downloaded(ctx.filename)
-                            self.try_rename(ctx.tmpfilename, ctx.filename)
-                            self._hook_progress({
-                                'filename': ctx.filename,
-                                'status': 'finished',
-                                'downloaded_bytes': ctx.resume_len,
-                                'total_bytes': ctx.resume_len,
-                            }, info_dict)
-                            raise SucceedDownload()
-                        else:
-                            # The length does not match, we start the download over
-                            self.report_unable_to_resume()
-                            ctx.resume_len = 0
-                            ctx.open_mode = 'wb'
-                            return
-                elif err.status < 500 or err.status >= 600:
-                    # Unexpected HTTP error
-                    raise
-                raise RetryDownload(err)
-            except CertificateVerifyError:
-                raise
-            except TransportError as err:
-                raise RetryDownload(err)
-
-        def close_stream():
-            if ctx.stream is not None:
-                if not ctx.tmpfilename == '-':
-                    ctx.stream.close()
-                ctx.stream = None
-
-        def download():
-            data_len = ctx.data.headers.get('Content-length')
-
-            if ctx.data.headers.get('Content-encoding'):
-                # Content-encoding is present, Content-length is not reliable anymore as we are
-                # doing auto decompression. (See: https://github.com/yt-dlp/yt-dlp/pull/6176)
-                data_len = None
-
-            # Range HTTP header may be ignored/unsupported by a webserver
-            # (e.g. extractor/scivee.py, extractor/bambuser.py).
-            # However, for a test we still would like to download just a piece of a file.
-            # To achieve this we limit data_len to _TEST_FILE_SIZE and manually control
-            # block size when downloading a file.
-            if is_test and (data_len is None or int(data_len) > self._TEST_FILE_SIZE):
-                data_len = self._TEST_FILE_SIZE
-
-            if data_len is not None:
-                data_len = int(data_len) + ctx.resume_len
-                min_data_len = self.params.get('min_filesize')
-                max_data_len = self.params.get('max_filesize')
-                if min_data_len is not None and data_len < min_data_len:
-                    self.to_screen(
-                        f'\r[download] File is smaller than min-filesize ({data_len} bytes < {min_data_len} bytes). Aborting.')
-                    return False
-                if max_data_len is not None and data_len > max_data_len:
-                    self.to_screen(
-                        f'\r[download] File is larger than max-filesize ({data_len} bytes > {max_data_len} bytes). Aborting.')
-                    return False
-
-            byte_counter = 0 + ctx.resume_len
-            block_size = ctx.block_size
-            start = time.time()
-
-            # measure time over whole while-loop, so slow_down() and best_block_size() work together properly
-            now = None  # needed for slow_down() in the first loop run
-            before = start  # start measuring
-
-            def retry(e):
-                close_stream()
-                if ctx.tmpfilename == '-':
-                    ctx.resume_len = byte_counter
-                else:
-                    try:
-                        ctx.resume_len = os.path.getsize(encodeFilename(ctx.tmpfilename))
-                    except FileNotFoundError:
-                        ctx.resume_len = 0
-                raise RetryDownload(e)
-
-            while True:
-                try:
-                    # Download and write
-                    data_block = ctx.data.read(block_size if not is_test else min(block_size, data_len - byte_counter))
-                except TransportError as err:
-                    retry(err)
-
-                byte_counter += len(data_block)
-
-                # exit loop when download is finished
-                if len(data_block) == 0:
-                    break
-
-                # Open destination file just in time
-                if ctx.stream is None:
-                    try:
-                        ctx.stream, ctx.tmpfilename = self.sanitize_open(
-                            ctx.tmpfilename, ctx.open_mode)
-                        assert ctx.stream is not None
-                        ctx.filename = self.undo_temp_name(ctx.tmpfilename)
-                        self.report_destination(ctx.filename)
-                    except OSError as err:
-                        self.report_error('unable to open for writing: %s' % str(err))
-                        return False
-
-                    if self.params.get('xattr_set_filesize', False) and data_len is not None:
-                        try:
-                            write_xattr(ctx.tmpfilename, 'user.ytdl.filesize', str(data_len).encode())
-                        except (XAttrUnavailableError, XAttrMetadataError) as err:
-                            self.report_error('unable to set filesize xattr: %s' % str(err))
-
-                try:
-                    ctx.stream.write(data_block)
-                except OSError as err:
-                    self.to_stderr('\n')
-                    self.report_error('unable to write data: %s' % str(err))
-                    return False
-
-                # Apply rate limit
-                self.slow_down(start, now, byte_counter - ctx.resume_len)
-
-                # end measuring of one loop run
-                now = time.time()
-                after = now
-
-                # Adjust block size
-                if not self.params.get('noresizebuffer', False):
-                    block_size = self.best_block_size(after - before, len(data_block))
-
-                before = after
-
-                # Progress message
-                speed = self.calc_speed(start, now, byte_counter - ctx.resume_len)
-                if ctx.data_len is None:
-                    eta = None
-                else:
-                    eta = self.calc_eta(start, time.time(), ctx.data_len - ctx.resume_len, byte_counter - ctx.resume_len)
-
-                self._hook_progress({
-                    'status': 'downloading',
-                    'downloaded_bytes': byte_counter,
-                    'total_bytes': ctx.data_len,
-                    'tmpfilename': ctx.tmpfilename,
-                    'filename': ctx.filename,
-                    'eta': eta,
-                    'speed': speed,
-                    'elapsed': now - ctx.start_time,
-                    'ctx_id': info_dict.get('ctx_id'),
-                }, info_dict)
-
-                if data_len is not None and byte_counter == data_len:
-                    break
-
-                if speed and speed < (self.params.get('throttledratelimit') or 0):
-                    # The speed must stay below the limit for 3 seconds
-                    # This prevents raising error when the speed temporarily goes down
-                    if ctx.throttle_start is None:
-                        ctx.throttle_start = now
-                    elif now - ctx.throttle_start > 3:
-                        if ctx.stream is not None and ctx.tmpfilename != '-':
-                            ctx.stream.close()
-                        raise ThrottledDownload()
-                elif speed:
-                    ctx.throttle_start = None
-
-            if ctx.stream is None:
-                self.to_stderr('\n')
-                self.report_error('Did not get any data blocks')
-                return False
-
-            if not is_test and ctx.chunk_size and ctx.content_len is not None and byte_counter < ctx.content_len:
-                ctx.resume_len = byte_counter
-                raise NextFragment()
-
-            if ctx.tmpfilename != '-':
-                ctx.stream.close()
-
-            if data_len is not None and byte_counter != data_len:
-                err = ContentTooShortError(byte_counter, int(data_len))
-                retry(err)
-
-            self.try_rename(ctx.tmpfilename, ctx.filename)
-
-            # Update file modification time
-            if self.params.get('updatetime', True):
-                info_dict['filetime'] = self.try_utime(ctx.filename, ctx.data.headers.get('last-modified', None))
-
-            self._hook_progress({
-                'downloaded_bytes': byte_counter,
-                'total_bytes': byte_counter,
-                'filename': ctx.filename,
-                'status': 'finished',
-                'elapsed': time.time() - ctx.start_time,
-                'ctx_id': info_dict.get('ctx_id'),
-            }, info_dict)
-
-            return True
-
-        for retry in RetryManager(self.params.get('retries'), self.report_retry):
-            try:
-                establish_connection()
-                return download()
-            except RetryDownload as err:
-                retry.error = err.source_error
-                continue
-            except NextFragment:
-                retry.error = None
-                retry.attempt -= 1
-                continue
-            except SucceedDownload:
-                return True
-            except:  # noqa: E722
-                close_stream()
-                raise
-        return False

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/downloader/ism.py

@@ -1,283 +0,0 @@
-import binascii
-import io
-import struct
-import time
-
-from .fragment import FragmentFD
-from ..networking.exceptions import HTTPError
-from ..utils import RetryManager
-
-u8 = struct.Struct('>B')
-u88 = struct.Struct('>Bx')
-u16 = struct.Struct('>H')
-u1616 = struct.Struct('>Hxx')
-u32 = struct.Struct('>I')
-u64 = struct.Struct('>Q')
-
-s88 = struct.Struct('>bx')
-s16 = struct.Struct('>h')
-s1616 = struct.Struct('>hxx')
-s32 = struct.Struct('>i')
-
-unity_matrix = (s32.pack(0x10000) + s32.pack(0) * 3) * 2 + s32.pack(0x40000000)
-
-TRACK_ENABLED = 0x1
-TRACK_IN_MOVIE = 0x2
-TRACK_IN_PREVIEW = 0x4
-
-SELF_CONTAINED = 0x1
-
-
-def box(box_type, payload):
-    return u32.pack(8 + len(payload)) + box_type + payload
-
-
-def full_box(box_type, version, flags, payload):
-    return box(box_type, u8.pack(version) + u32.pack(flags)[1:] + payload)
-
-
-def write_piff_header(stream, params):
-    track_id = params['track_id']
-    fourcc = params['fourcc']
-    duration = params['duration']
-    timescale = params.get('timescale', 10000000)
-    language = params.get('language', 'und')
-    height = params.get('height', 0)
-    width = params.get('width', 0)
-    stream_type = params['stream_type']
-    creation_time = modification_time = int(time.time())
-
-    ftyp_payload = b'isml'  # major brand
-    ftyp_payload += u32.pack(1)  # minor version
-    ftyp_payload += b'piff' + b'iso2'  # compatible brands
-    stream.write(box(b'ftyp', ftyp_payload))  # File Type Box
-
-    mvhd_payload = u64.pack(creation_time)
-    mvhd_payload += u64.pack(modification_time)
-    mvhd_payload += u32.pack(timescale)
-    mvhd_payload += u64.pack(duration)
-    mvhd_payload += s1616.pack(1)  # rate
-    mvhd_payload += s88.pack(1)  # volume
-    mvhd_payload += u16.pack(0)  # reserved
-    mvhd_payload += u32.pack(0) * 2  # reserved
-    mvhd_payload += unity_matrix
-    mvhd_payload += u32.pack(0) * 6  # pre defined
-    mvhd_payload += u32.pack(0xffffffff)  # next track id
-    moov_payload = full_box(b'mvhd', 1, 0, mvhd_payload)  # Movie Header Box
-
-    tkhd_payload = u64.pack(creation_time)
-    tkhd_payload += u64.pack(modification_time)
-    tkhd_payload += u32.pack(track_id)  # track id
-    tkhd_payload += u32.pack(0)  # reserved
-    tkhd_payload += u64.pack(duration)
-    tkhd_payload += u32.pack(0) * 2  # reserved
-    tkhd_payload += s16.pack(0)  # layer
-    tkhd_payload += s16.pack(0)  # alternate group
-    tkhd_payload += s88.pack(1 if stream_type == 'audio' else 0)  # volume
-    tkhd_payload += u16.pack(0)  # reserved
-    tkhd_payload += unity_matrix
-    tkhd_payload += u1616.pack(width)
-    tkhd_payload += u1616.pack(height)
-    trak_payload = full_box(b'tkhd', 1, TRACK_ENABLED | TRACK_IN_MOVIE | TRACK_IN_PREVIEW, tkhd_payload)  # Track Header Box
-
-    mdhd_payload = u64.pack(creation_time)
-    mdhd_payload += u64.pack(modification_time)
-    mdhd_payload += u32.pack(timescale)
-    mdhd_payload += u64.pack(duration)
-    mdhd_payload += u16.pack(((ord(language[0]) - 0x60) << 10) | ((ord(language[1]) - 0x60) << 5) | (ord(language[2]) - 0x60))
-    mdhd_payload += u16.pack(0)  # pre defined
-    mdia_payload = full_box(b'mdhd', 1, 0, mdhd_payload)  # Media Header Box
-
-    hdlr_payload = u32.pack(0)  # pre defined
-    if stream_type == 'audio':  # handler type
-        hdlr_payload += b'soun'
-        hdlr_payload += u32.pack(0) * 3  # reserved
-        hdlr_payload += b'SoundHandler\0'  # name
-    elif stream_type == 'video':
-        hdlr_payload += b'vide'
-        hdlr_payload += u32.pack(0) * 3  # reserved
-        hdlr_payload += b'VideoHandler\0'  # name
-    elif stream_type == 'text':
-        hdlr_payload += b'subt'
-        hdlr_payload += u32.pack(0) * 3  # reserved
-        hdlr_payload += b'SubtitleHandler\0'  # name
-    else:
-        assert False
-    mdia_payload += full_box(b'hdlr', 0, 0, hdlr_payload)  # Handler Reference Box
-
-    if stream_type == 'audio':
-        smhd_payload = s88.pack(0)  # balance
-        smhd_payload += u16.pack(0)  # reserved
-        media_header_box = full_box(b'smhd', 0, 0, smhd_payload)  # Sound Media Header
-    elif stream_type == 'video':
-        vmhd_payload = u16.pack(0)  # graphics mode
-        vmhd_payload += u16.pack(0) * 3  # opcolor
-        media_header_box = full_box(b'vmhd', 0, 1, vmhd_payload)  # Video Media Header
-    elif stream_type == 'text':
-        media_header_box = full_box(b'sthd', 0, 0, b'')  # Subtitle Media Header
-    else:
-        assert False
-    minf_payload = media_header_box
-
-    dref_payload = u32.pack(1)  # entry count
-    dref_payload += full_box(b'url ', 0, SELF_CONTAINED, b'')  # Data Entry URL Box
-    dinf_payload = full_box(b'dref', 0, 0, dref_payload)  # Data Reference Box
-    minf_payload += box(b'dinf', dinf_payload)  # Data Information Box
-
-    stsd_payload = u32.pack(1)  # entry count
-
-    sample_entry_payload = u8.pack(0) * 6  # reserved
-    sample_entry_payload += u16.pack(1)  # data reference index
-    if stream_type == 'audio':
-        sample_entry_payload += u32.pack(0) * 2  # reserved
-        sample_entry_payload += u16.pack(params.get('channels', 2))
-        sample_entry_payload += u16.pack(params.get('bits_per_sample', 16))
-        sample_entry_payload += u16.pack(0)  # pre defined
-        sample_entry_payload += u16.pack(0)  # reserved
-        sample_entry_payload += u1616.pack(params['sampling_rate'])
-
-        if fourcc == 'AACL':
-            sample_entry_box = box(b'mp4a', sample_entry_payload)
-        if fourcc == 'EC-3':
-            sample_entry_box = box(b'ec-3', sample_entry_payload)
-    elif stream_type == 'video':
-        sample_entry_payload += u16.pack(0)  # pre defined
-        sample_entry_payload += u16.pack(0)  # reserved
-        sample_entry_payload += u32.pack(0) * 3  # pre defined
-        sample_entry_payload += u16.pack(width)
-        sample_entry_payload += u16.pack(height)
-        sample_entry_payload += u1616.pack(0x48)  # horiz resolution 72 dpi
-        sample_entry_payload += u1616.pack(0x48)  # vert resolution 72 dpi
-        sample_entry_payload += u32.pack(0)  # reserved
-        sample_entry_payload += u16.pack(1)  # frame count
-        sample_entry_payload += u8.pack(0) * 32  # compressor name
-        sample_entry_payload += u16.pack(0x18)  # depth
-        sample_entry_payload += s16.pack(-1)  # pre defined
-
-        codec_private_data = binascii.unhexlify(params['codec_private_data'].encode())
-        if fourcc in ('H264', 'AVC1'):
-            sps, pps = codec_private_data.split(u32.pack(1))[1:]
-            avcc_payload = u8.pack(1)  # configuration version
-            avcc_payload += sps[1:4]  # avc profile indication + profile compatibility + avc level indication
-            avcc_payload += u8.pack(0xfc | (params.get('nal_unit_length_field', 4) - 1))  # complete representation (1) + reserved (11111) + length size minus one
-            avcc_payload += u8.pack(1)  # reserved (0) + number of sps (0000001)
-            avcc_payload += u16.pack(len(sps))
-            avcc_payload += sps
-            avcc_payload += u8.pack(1)  # number of pps
-            avcc_payload += u16.pack(len(pps))
-            avcc_payload += pps
-            sample_entry_payload += box(b'avcC', avcc_payload)  # AVC Decoder Configuration Record
-            sample_entry_box = box(b'avc1', sample_entry_payload)  # AVC Simple Entry
-        else:
-            assert False
-    elif stream_type == 'text':
-        if fourcc == 'TTML':
-            sample_entry_payload += b'http://www.w3.org/ns/ttml\0'  # namespace
-            sample_entry_payload += b'\0'  # schema location
-            sample_entry_payload += b'\0'  # auxilary mime types(??)
-            sample_entry_box = box(b'stpp', sample_entry_payload)
-        else:
-            assert False
-    else:
-        assert False
-    stsd_payload += sample_entry_box
-
-    stbl_payload = full_box(b'stsd', 0, 0, stsd_payload)  # Sample Description Box
-
-    stts_payload = u32.pack(0)  # entry count
-    stbl_payload += full_box(b'stts', 0, 0, stts_payload)  # Decoding Time to Sample Box
-
-    stsc_payload = u32.pack(0)  # entry count
-    stbl_payload += full_box(b'stsc', 0, 0, stsc_payload)  # Sample To Chunk Box
-
-    stco_payload = u32.pack(0)  # entry count
-    stbl_payload += full_box(b'stco', 0, 0, stco_payload)  # Chunk Offset Box
-
-    minf_payload += box(b'stbl', stbl_payload)  # Sample Table Box
-
-    mdia_payload += box(b'minf', minf_payload)  # Media Information Box
-
-    trak_payload += box(b'mdia', mdia_payload)  # Media Box
-
-    moov_payload += box(b'trak', trak_payload)  # Track Box
-
-    mehd_payload = u64.pack(duration)
-    mvex_payload = full_box(b'mehd', 1, 0, mehd_payload)  # Movie Extends Header Box
-
-    trex_payload = u32.pack(track_id)  # track id
-    trex_payload += u32.pack(1)  # default sample description index
-    trex_payload += u32.pack(0)  # default sample duration
-    trex_payload += u32.pack(0)  # default sample size
-    trex_payload += u32.pack(0)  # default sample flags
-    mvex_payload += full_box(b'trex', 0, 0, trex_payload)  # Track Extends Box
-
-    moov_payload += box(b'mvex', mvex_payload)  # Movie Extends Box
-    stream.write(box(b'moov', moov_payload))  # Movie Box
-
-
-def extract_box_data(data, box_sequence):
-    data_reader = io.BytesIO(data)
-    while True:
-        box_size = u32.unpack(data_reader.read(4))[0]
-        box_type = data_reader.read(4)
-        if box_type == box_sequence[0]:
-            box_data = data_reader.read(box_size - 8)
-            if len(box_sequence) == 1:
-                return box_data
-            return extract_box_data(box_data, box_sequence[1:])
-        data_reader.seek(box_size - 8, 1)
-
-
-class IsmFD(FragmentFD):
-    """
-    Download segments in a ISM manifest
-    """
-
-    def real_download(self, filename, info_dict):
-        segments = info_dict['fragments'][:1] if self.params.get(
-            'test', False) else info_dict['fragments']
-
-        ctx = {
-            'filename': filename,
-            'total_frags': len(segments),
-        }
-
-        self._prepare_and_start_frag_download(ctx, info_dict)
-
-        extra_state = ctx.setdefault('extra_state', {
-            'ism_track_written': False,
-        })
-
-        skip_unavailable_fragments = self.params.get('skip_unavailable_fragments', True)
-
-        frag_index = 0
-        for i, segment in enumerate(segments):
-            frag_index += 1
-            if frag_index <= ctx['fragment_index']:
-                continue
-
-            retry_manager = RetryManager(self.params.get('fragment_retries'), self.report_retry,
-                                         frag_index=frag_index, fatal=not skip_unavailable_fragments)
-            for retry in retry_manager:
-                try:
-                    success = self._download_fragment(ctx, segment['url'], info_dict)
-                    if not success:
-                        return False
-                    frag_content = self._read_fragment(ctx)
-
-                    if not extra_state['ism_track_written']:
-                        tfhd_data = extract_box_data(frag_content, [b'moof', b'traf', b'tfhd'])
-                        info_dict['_download_params']['track_id'] = u32.unpack(tfhd_data[4:8])[0]
-                        write_piff_header(ctx['dest_stream'], info_dict['_download_params'])
-                        extra_state['ism_track_written'] = True
-                    self._append_fragment(ctx, frag_content)
-                except HTTPError as err:
-                    retry.error = err
-                    continue
-
-            if retry_manager.error:
-                if not skip_unavailable_fragments:
-                    return False
-                self.report_skip_fragment(frag_index)
-
-        return self._finish_frag_download(ctx, info_dict)