npm - @tushar-br/desktop - Versions diffs - 1.0.283 → 1.0.284 - Mend

@tushar-br/desktop 1.0.283 → 1.0.284

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of @tushar-br/desktop might be problematic. Click here for more details.

Files changed (3797) hide show

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

@@ -1,189 +0,0 @@
-import io
-import quopri
-import re
-import uuid
-from .fragment import FragmentFD
-from ..compat import imghdr
-from ..utils import escapeHTML, formatSeconds, srt_subtitles_timecode, urljoin
-from ..version import __version__ as YT_DLP_VERSION
-class MhtmlFD(FragmentFD):
-    _STYLESHEET = """\
-html, body {
-    margin: 0;
-    padding: 0;
-    height: 100vh;
-}
-html {
-    overflow-y: scroll;
-    scroll-snap-type: y mandatory;
-}
-body {
-    scroll-snap-type: y mandatory;
-    display: flex;
-    flex-flow: column;
-}
-body > figure {
-    max-width: 100vw;
-    max-height: 100vh;
-    scroll-snap-align: center;
-}
-body > figure > figcaption {
-    text-align: center;
-    height: 2.5em;
-}
-body > figure > img {
-    display: block;
-    margin: auto;
-    max-width: 100%;
-    max-height: calc(100vh - 5em);
-}
-"""
-    _STYLESHEET = re.sub(r'\s+', ' ', _STYLESHEET)
-    _STYLESHEET = re.sub(r'\B \B|(?<=[\w\-]) (?=[^\w\-])|(?<=[^\w\-]) (?=[\w\-])', '', _STYLESHEET)
-    @staticmethod
-    def _escape_mime(s):
-        return '=?utf-8?Q?' + (b''.join(
-            bytes((b,)) if b >= 0x20 else b'=%02X' % b
-            for b in quopri.encodestring(s.encode(), header=True)
-        )).decode('us-ascii') + '?='
-    def _gen_cid(self, i, fragment, frag_boundary):
-        return '%u.%s@yt-dlp.github.io.invalid' % (i, frag_boundary)
-    def _gen_stub(self, *, fragments, frag_boundary, title):
-        output = io.StringIO()
-        output.write((
-            '<!DOCTYPE html>'
-            '<html>'
-            '<head>'
-            ''  '<meta name="generator" content="yt-dlp {version}">'
-            ''  '<title>{title}</title>'
-            ''  '<style>{styles}</style>'
-            '<body>'
-        ).format(
-            version=escapeHTML(YT_DLP_VERSION),
-            styles=self._STYLESHEET,
-            title=escapeHTML(title)
-        ))
-        t0 = 0
-        for i, frag in enumerate(fragments):
-            output.write('<figure>')
-            try:
-                t1 = t0 + frag['duration']
-                output.write((
-                    '<figcaption>Slide #{num}: {t0} – {t1} (duration: {duration})</figcaption>'
-                ).format(
-                    num=i + 1,
-                    t0=srt_subtitles_timecode(t0),
-                    t1=srt_subtitles_timecode(t1),
-                    duration=formatSeconds(frag['duration'], msec=True)
-                ))
-            except (KeyError, ValueError, TypeError):
-                t1 = None
-                output.write((
-                    '<figcaption>Slide #{num}</figcaption>'
-                ).format(num=i + 1))
-            output.write('<img src="cid:{cid}">'.format(
-                cid=self._gen_cid(i, frag, frag_boundary)))
-            output.write('</figure>')
-            t0 = t1
-        return output.getvalue()
-    def real_download(self, filename, info_dict):
-        fragment_base_url = info_dict.get('fragment_base_url')
-        fragments = info_dict['fragments'][:1] if self.params.get(
-            'test', False) else info_dict['fragments']
-        title = info_dict.get('title', info_dict['format_id'])
-        origin = info_dict.get('webpage_url', info_dict['url'])
-        ctx = {
-            'filename': filename,
-            'total_frags': len(fragments),
-        }
-        self._prepare_and_start_frag_download(ctx, info_dict)
-        extra_state = ctx.setdefault('extra_state', {
-            'header_written': False,
-            'mime_boundary': str(uuid.uuid4()).replace('-', ''),
-        })
-        frag_boundary = extra_state['mime_boundary']
-        if not extra_state['header_written']:
-            stub = self._gen_stub(
-                fragments=fragments,
-                frag_boundary=frag_boundary,
-                title=title
-            )
-            ctx['dest_stream'].write((
-                'MIME-Version: 1.0\r\n'
-                'From: <nowhere@yt-dlp.github.io.invalid>\r\n'
-                'To: <nowhere@yt-dlp.github.io.invalid>\r\n'
-                'Subject: {title}\r\n'
-                'Content-type: multipart/related; '
-                ''  'boundary="{boundary}"; '
-                ''  'type="text/html"\r\n'
-                'X.yt-dlp.Origin: {origin}\r\n'
-                '\r\n'
-                '--{boundary}\r\n'
-                'Content-Type: text/html; charset=utf-8\r\n'
-                'Content-Length: {length}\r\n'
-                '\r\n'
-                '{stub}\r\n'
-            ).format(
-                origin=origin,
-                boundary=frag_boundary,
-                length=len(stub),
-                title=self._escape_mime(title),
-                stub=stub
-            ).encode())
-            extra_state['header_written'] = True
-        for i, fragment in enumerate(fragments):
-            if (i + 1) <= ctx['fragment_index']:
-                continue
-            fragment_url = fragment.get('url')
-            if not fragment_url:
-                assert fragment_base_url
-                fragment_url = urljoin(fragment_base_url, fragment['path'])
-            success = self._download_fragment(ctx, fragment_url, info_dict)
-            if not success:
-                continue
-            frag_content = self._read_fragment(ctx)
-            frag_header = io.BytesIO()
-            frag_header.write(
-                b'--%b\r\n' % frag_boundary.encode('us-ascii'))
-            frag_header.write(
-                b'Content-ID: <%b>\r\n' % self._gen_cid(i, fragment, frag_boundary).encode('us-ascii'))
-            frag_header.write(
-                b'Content-type: %b\r\n' % f'image/{imghdr.what(h=frag_content) or "jpeg"}'.encode())
-            frag_header.write(
-                b'Content-length: %u\r\n' % len(frag_content))
-            frag_header.write(
-                b'Content-location: %b\r\n' % fragment_url.encode('us-ascii'))
-            frag_header.write(
-                b'X.yt-dlp.Duration: %f\r\n' % fragment['duration'])
-            frag_header.write(b'\r\n')
-            self._append_fragment(
-                ctx, frag_header.getvalue() + frag_content + b'\r\n')
-        ctx['dest_stream'].write(
-            b'--%b--\r\n\r\n' % frag_boundary.encode('us-ascii'))
-        return self._finish_frag_download(ctx, info_dict)

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

@@ -1,140 +0,0 @@
-import json
-import threading
-import time
-from . import get_suitable_downloader
-from .common import FileDownloader
-from .external import FFmpegFD
-from ..networking import Request
-from ..utils import DownloadError, str_or_none, try_get
-class NiconicoDmcFD(FileDownloader):
-    """ Downloading niconico douga from DMC with heartbeat """
-    def real_download(self, filename, info_dict):
-        from ..extractor.niconico import NiconicoIE
-        self.to_screen('[%s] Downloading from DMC' % self.FD_NAME)
-        ie = NiconicoIE(self.ydl)
-        info_dict, heartbeat_info_dict = ie._get_heartbeat_info(info_dict)
-        fd = get_suitable_downloader(info_dict, params=self.params)(self.ydl, self.params)
-        success = download_complete = False
-        timer = [None]
-        heartbeat_lock = threading.Lock()
-        heartbeat_url = heartbeat_info_dict['url']
-        heartbeat_data = heartbeat_info_dict['data'].encode()
-        heartbeat_interval = heartbeat_info_dict.get('interval', 30)
-        request = Request(heartbeat_url, heartbeat_data)
-        def heartbeat():
-            try:
-                self.ydl.urlopen(request).read()
-            except Exception:
-                self.to_screen('[%s] Heartbeat failed' % self.FD_NAME)
-            with heartbeat_lock:
-                if not download_complete:
-                    timer[0] = threading.Timer(heartbeat_interval, heartbeat)
-                    timer[0].start()
-        heartbeat_info_dict['ping']()
-        self.to_screen('[%s] Heartbeat with %d second interval ...' % (self.FD_NAME, heartbeat_interval))
-        try:
-            heartbeat()
-            if type(fd).__name__ == 'HlsFD':
-                info_dict.update(ie._extract_m3u8_formats(info_dict['url'], info_dict['id'])[0])
-            success = fd.real_download(filename, info_dict)
-        finally:
-            if heartbeat_lock:
-                with heartbeat_lock:
-                    timer[0].cancel()
-                    download_complete = True
-        return success
-class NiconicoLiveFD(FileDownloader):
-    """ Downloads niconico live without being stopped """
-    def real_download(self, filename, info_dict):
-        video_id = info_dict['video_id']
-        ws_url = info_dict['url']
-        ws_extractor = info_dict['ws']
-        ws_origin_host = info_dict['origin']
-        live_quality = info_dict.get('live_quality', 'high')
-        live_latency = info_dict.get('live_latency', 'high')
-        dl = FFmpegFD(self.ydl, self.params or {})
-        new_info_dict = info_dict.copy()
-        new_info_dict.update({
-            'protocol': 'm3u8',
-        })
-        def communicate_ws(reconnect):
-            if reconnect:
-                ws = self.ydl.urlopen(Request(ws_url, headers={'Origin': f'https://{ws_origin_host}'}))
-                if self.ydl.params.get('verbose', False):
-                    self.to_screen('[debug] Sending startWatching request')
-                ws.send(json.dumps({
-                    'type': 'startWatching',
-                    'data': {
-                        'stream': {
-                            'quality': live_quality,
-                            'protocol': 'hls+fmp4',
-                            'latency': live_latency,
-                            'chasePlay': False
-                        },
-                        'room': {
-                            'protocol': 'webSocket',
-                            'commentable': True
-                        },
-                        'reconnect': True,
-                    }
-                }))
-            else:
-                ws = ws_extractor
-            with ws:
-                while True:
-                    recv = ws.recv()
-                    if not recv:
-                        continue
-                    data = json.loads(recv)
-                    if not data or not isinstance(data, dict):
-                        continue
-                    if data.get('type') == 'ping':
-                        # pong back
-                        ws.send(r'{"type":"pong"}')
-                        ws.send(r'{"type":"keepSeat"}')
-                    elif data.get('type') == 'disconnect':
-                        self.write_debug(data)
-                        return True
-                    elif data.get('type') == 'error':
-                        self.write_debug(data)
-                        message = try_get(data, lambda x: x['body']['code'], str) or recv
-                        return DownloadError(message)
-                    elif self.ydl.params.get('verbose', False):
-                        if len(recv) > 100:
-                            recv = recv[:100] + '...'
-                        self.to_screen('[debug] Server said: %s' % recv)
-        def ws_main():
-            reconnect = False
-            while True:
-                try:
-                    ret = communicate_ws(reconnect)
-                    if ret is True:
-                        return
-                except BaseException as e:
-                    self.to_screen('[%s] %s: Connection error occured, reconnecting after 10 seconds: %s' % ('niconico:live', video_id, str_or_none(e)))
-                    time.sleep(10)
-                    continue
-                finally:
-                    reconnect = True
-        thread = threading.Thread(target=ws_main, daemon=True)
-        thread.start()
-        return dl.download(filename, new_info_dict)

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

@@ -1,213 +0,0 @@
-import os
-import re
-import subprocess
-import time
-from .common import FileDownloader
-from ..utils import (
-    Popen,
-    check_executable,
-    encodeArgument,
-    encodeFilename,
-    get_exe_version,
-)
-def rtmpdump_version():
-    return get_exe_version(
-        'rtmpdump', ['--help'], r'(?i)RTMPDump\s*v?([0-9a-zA-Z._-]+)')
-class RtmpFD(FileDownloader):
-    def real_download(self, filename, info_dict):
-        def run_rtmpdump(args):
-            start = time.time()
-            resume_percent = None
-            resume_downloaded_data_len = None
-            proc = Popen(args, stderr=subprocess.PIPE)
-            cursor_in_new_line = True
-            proc_stderr_closed = False
-            try:
-                while not proc_stderr_closed:
-                    # read line from stderr
-                    line = ''
-                    while True:
-                        char = proc.stderr.read(1)
-                        if not char:
-                            proc_stderr_closed = True
-                            break
-                        if char in [b'\r', b'\n']:
-                            break
-                        line += char.decode('ascii', 'replace')
-                    if not line:
-                        # proc_stderr_closed is True
-                        continue
-                    mobj = re.search(r'([0-9]+\.[0-9]{3}) kB / [0-9]+\.[0-9]{2} sec \(([0-9]{1,2}\.[0-9])%\)', line)
-                    if mobj:
-                        downloaded_data_len = int(float(mobj.group(1)) * 1024)
-                        percent = float(mobj.group(2))
-                        if not resume_percent:
-                            resume_percent = percent
-                            resume_downloaded_data_len = downloaded_data_len
-                        time_now = time.time()
-                        eta = self.calc_eta(start, time_now, 100 - resume_percent, percent - resume_percent)
-                        speed = self.calc_speed(start, time_now, downloaded_data_len - resume_downloaded_data_len)
-                        data_len = None
-                        if percent > 0:
-                            data_len = int(downloaded_data_len * 100 / percent)
-                        self._hook_progress({
-                            'status': 'downloading',
-                            'downloaded_bytes': downloaded_data_len,
-                            'total_bytes_estimate': data_len,
-                            'tmpfilename': tmpfilename,
-                            'filename': filename,
-                            'eta': eta,
-                            'elapsed': time_now - start,
-                            'speed': speed,
-                        }, info_dict)
-                        cursor_in_new_line = False
-                    else:
-                        # no percent for live streams
-                        mobj = re.search(r'([0-9]+\.[0-9]{3}) kB / [0-9]+\.[0-9]{2} sec', line)
-                        if mobj:
-                            downloaded_data_len = int(float(mobj.group(1)) * 1024)
-                            time_now = time.time()
-                            speed = self.calc_speed(start, time_now, downloaded_data_len)
-                            self._hook_progress({
-                                'downloaded_bytes': downloaded_data_len,
-                                'tmpfilename': tmpfilename,
-                                'filename': filename,
-                                'status': 'downloading',
-                                'elapsed': time_now - start,
-                                'speed': speed,
-                            }, info_dict)
-                            cursor_in_new_line = False
-                        elif self.params.get('verbose', False):
-                            if not cursor_in_new_line:
-                                self.to_screen('')
-                            cursor_in_new_line = True
-                            self.to_screen('[rtmpdump] ' + line)
-                if not cursor_in_new_line:
-                    self.to_screen('')
-                return proc.wait()
-            except BaseException:  # Including KeyboardInterrupt
-                proc.kill(timeout=None)
-                raise
-        url = info_dict['url']
-        player_url = info_dict.get('player_url')
-        page_url = info_dict.get('page_url')
-        app = info_dict.get('app')
-        play_path = info_dict.get('play_path')
-        tc_url = info_dict.get('tc_url')
-        flash_version = info_dict.get('flash_version')
-        live = info_dict.get('rtmp_live', False)
-        conn = info_dict.get('rtmp_conn')
-        protocol = info_dict.get('rtmp_protocol')
-        real_time = info_dict.get('rtmp_real_time', False)
-        no_resume = info_dict.get('no_resume', False)
-        continue_dl = self.params.get('continuedl', True)
-        self.report_destination(filename)
-        tmpfilename = self.temp_name(filename)
-        test = self.params.get('test', False)
-        # Check for rtmpdump first
-        if not check_executable('rtmpdump', ['-h']):
-            self.report_error('RTMP download detected but "rtmpdump" could not be run. Please install')
-            return False
-        # Download using rtmpdump. rtmpdump returns exit code 2 when
-        # the connection was interrupted and resuming appears to be
-        # possible. This is part of rtmpdump's normal usage, AFAIK.
-        basic_args = [
-            'rtmpdump', '--verbose', '-r', url,
-            '-o', tmpfilename]
-        if player_url is not None:
-            basic_args += ['--swfVfy', player_url]
-        if page_url is not None:
-            basic_args += ['--pageUrl', page_url]
-        if app is not None:
-            basic_args += ['--app', app]
-        if play_path is not None:
-            basic_args += ['--playpath', play_path]
-        if tc_url is not None:
-            basic_args += ['--tcUrl', tc_url]
-        if test:
-            basic_args += ['--stop', '1']
-        if flash_version is not None:
-            basic_args += ['--flashVer', flash_version]
-        if live:
-            basic_args += ['--live']
-        if isinstance(conn, list):
-            for entry in conn:
-                basic_args += ['--conn', entry]
-        elif isinstance(conn, str):
-            basic_args += ['--conn', conn]
-        if protocol is not None:
-            basic_args += ['--protocol', protocol]
-        if real_time:
-            basic_args += ['--realtime']
-        args = basic_args
-        if not no_resume and continue_dl and not live:
-            args += ['--resume']
-        if not live and continue_dl:
-            args += ['--skip', '1']
-        args = [encodeArgument(a) for a in args]
-        self._debug_cmd(args, exe='rtmpdump')
-        RD_SUCCESS = 0
-        RD_FAILED = 1
-        RD_INCOMPLETE = 2
-        RD_NO_CONNECT = 3
-        started = time.time()
-        try:
-            retval = run_rtmpdump(args)
-        except KeyboardInterrupt:
-            if not info_dict.get('is_live'):
-                raise
-            retval = RD_SUCCESS
-            self.to_screen('\n[rtmpdump] Interrupted by user')
-        if retval == RD_NO_CONNECT:
-            self.report_error('[rtmpdump] Could not connect to RTMP server.')
-            return False
-        while retval in (RD_INCOMPLETE, RD_FAILED) and not test and not live:
-            prevsize = os.path.getsize(encodeFilename(tmpfilename))
-            self.to_screen('[rtmpdump] Downloaded %s bytes' % prevsize)
-            time.sleep(5.0)  # This seems to be needed
-            args = basic_args + ['--resume']
-            if retval == RD_FAILED:
-                args += ['--skip', '1']
-            args = [encodeArgument(a) for a in args]
-            retval = run_rtmpdump(args)
-            cursize = os.path.getsize(encodeFilename(tmpfilename))
-            if prevsize == cursize and retval == RD_FAILED:
-                break
-            # Some rtmp streams seem abort after ~ 99.8%. Don't complain for those
-            if prevsize == cursize and retval == RD_INCOMPLETE and cursize > 1024:
-                self.to_screen('[rtmpdump] Could not download the whole video. This can happen for some advertisements.')
-                retval = RD_SUCCESS
-                break
-        if retval == RD_SUCCESS or (test and retval == RD_INCOMPLETE):
-            fsize = os.path.getsize(encodeFilename(tmpfilename))
-            self.to_screen('[rtmpdump] Downloaded %s bytes' % fsize)
-            self.try_rename(tmpfilename, filename)
-            self._hook_progress({
-                'downloaded_bytes': fsize,
-                'total_bytes': fsize,
-                'filename': filename,
-                'status': 'finished',
-                'elapsed': time.time() - started,
-            }, info_dict)
-            return True
-        else:
-            self.to_stderr('\n')
-            self.report_error('rtmpdump exited with code %d' % retval)
-            return False

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

@@ -1,42 +0,0 @@
-import os
-import subprocess
-from .common import FileDownloader
-from ..utils import check_executable, encodeFilename
-class RtspFD(FileDownloader):
-    def real_download(self, filename, info_dict):
-        url = info_dict['url']
-        self.report_destination(filename)
-        tmpfilename = self.temp_name(filename)
-        if check_executable('mplayer', ['-h']):
-            args = [
-                'mplayer', '-really-quiet', '-vo', 'null', '-vc', 'dummy',
-                '-dumpstream', '-dumpfile', tmpfilename, url]
-        elif check_executable('mpv', ['-h']):
-            args = [
-                'mpv', '-really-quiet', '--vo=null', '--stream-dump=' + tmpfilename, url]
-        else:
-            self.report_error('MMS or RTSP download detected but neither "mplayer" nor "mpv" could be run. Please install one')
-            return False
-        self._debug_cmd(args)
-        retval = subprocess.call(args)
-        if retval == 0:
-            fsize = os.path.getsize(encodeFilename(tmpfilename))
-            self.to_screen(f'\r[{args[0]}] {fsize} bytes')
-            self.try_rename(tmpfilename, filename)
-            self._hook_progress({
-                'downloaded_bytes': fsize,
-                'total_bytes': fsize,
-                'filename': filename,
-                'status': 'finished',
-            }, info_dict)
-            return True
-        else:
-            self.to_stderr('\n')
-            self.report_error('%s exited with code %d' % (args[0], retval))
-            return False

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

@@ -1,53 +0,0 @@
-import asyncio
-import contextlib
-import os
-import signal
-import threading
-from .common import FileDownloader
-from .external import FFmpegFD
-from ..dependencies import websockets
-class FFmpegSinkFD(FileDownloader):
-    """ A sink to ffmpeg for downloading fragments in any form """
-    def real_download(self, filename, info_dict):
-        info_copy = info_dict.copy()
-        info_copy['url'] = '-'
-        async def call_conn(proc, stdin):
-            try:
-                await self.real_connection(stdin, info_dict)
-            except OSError:
-                pass
-            finally:
-                with contextlib.suppress(OSError):
-                    stdin.flush()
-                    stdin.close()
-                os.kill(os.getpid(), signal.SIGINT)
-        class FFmpegStdinFD(FFmpegFD):
-            @classmethod
-            def get_basename(cls):
-                return FFmpegFD.get_basename()
-            def on_process_started(self, proc, stdin):
-                thread = threading.Thread(target=asyncio.run, daemon=True, args=(call_conn(proc, stdin), ))
-                thread.start()
-        return FFmpegStdinFD(self.ydl, self.params or {}).download(filename, info_copy)
-    async def real_connection(self, sink, info_dict):
-        """ Override this in subclasses """
-        raise NotImplementedError('This method must be implemented by subclasses')
-class WebSocketFragmentFD(FFmpegSinkFD):
-    async def real_connection(self, sink, info_dict):
-        async with websockets.connect(info_dict['url'], extra_headers=info_dict.get('http_headers', {})) as ws:
-            while True:
-                recv = await ws.recv()
-                if isinstance(recv, str):
-                    recv = recv.encode('utf8')
-                sink.write(recv)