@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/dependencies/Cryptodome.py

@@ -1,38 +0,0 @@
-from ..compat.compat_utils import passthrough_module
-
-try:
-    import Cryptodome as _parent
-except ImportError:
-    try:
-        import Crypto as _parent
-    except (ImportError, SyntaxError):  # Old Crypto gives SyntaxError in newer Python
-        _parent = passthrough_module(__name__, 'no_Cryptodome')
-        __bool__ = lambda: False
-
-del passthrough_module
-
-__version__ = ''
-AES = PKCS1_v1_5 = Blowfish = PKCS1_OAEP = SHA1 = CMAC = RSA = None
-try:
-    if _parent.__name__ == 'Cryptodome':
-        from Cryptodome import __version__
-        from Cryptodome.Cipher import AES, PKCS1_OAEP, Blowfish, PKCS1_v1_5
-        from Cryptodome.Hash import CMAC, SHA1
-        from Cryptodome.PublicKey import RSA
-    elif _parent.__name__ == 'Crypto':
-        from Crypto import __version__
-        from Crypto.Cipher import AES, PKCS1_OAEP, Blowfish, PKCS1_v1_5  # noqa: F401
-        from Crypto.Hash import CMAC, SHA1  # noqa: F401
-        from Crypto.PublicKey import RSA  # noqa: F401
-except ImportError:
-    __version__ = f'broken {__version__}'.strip()
-
-
-_yt_dlp__identifier = _parent.__name__
-if AES and _yt_dlp__identifier == 'Crypto':
-    try:
-        # In pycrypto, mode defaults to ECB. See:
-        # https://www.pycryptodome.org/en/latest/src/vs_pycrypto.html#:~:text=not%20have%20ECB%20as%20default%20mode
-        AES.new(b'abcdefghijklmnop')
-    except TypeError:
-        _yt_dlp__identifier = 'pycrypto'

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

@@ -1,92 +0,0 @@
-# flake8: noqa: F401
-"""Imports all optional dependencies for the project.
-An attribute "_yt_dlp__identifier" may be inserted into the module if it uses an ambiguous namespace"""
-
-try:
-    import brotlicffi as brotli
-except ImportError:
-    try:
-        import brotli
-    except ImportError:
-        brotli = None
-
-
-try:
-    import certifi
-except ImportError:
-    certifi = None
-else:
-    from os.path import exists as _path_exists
-
-    # The certificate may not be bundled in executable
-    if not _path_exists(certifi.where()):
-        certifi = None
-
-
-try:
-    import mutagen
-except ImportError:
-    mutagen = None
-
-
-secretstorage = None
-try:
-    import secretstorage
-    _SECRETSTORAGE_UNAVAILABLE_REASON = None
-except ImportError:
-    _SECRETSTORAGE_UNAVAILABLE_REASON = (
-        'as the `secretstorage` module is not installed. '
-        'Please install by running `python3 -m pip install secretstorage`')
-except Exception as _err:
-    _SECRETSTORAGE_UNAVAILABLE_REASON = f'as the `secretstorage` module could not be initialized. {_err}'
-
-
-try:
-    import sqlite3
-    # We need to get the underlying `sqlite` version, see https://github.com/yt-dlp/yt-dlp/issues/8152
-    sqlite3._yt_dlp__version = sqlite3.sqlite_version
-except ImportError:
-    # although sqlite3 is part of the standard library, it is possible to compile Python without
-    # sqlite support. See: https://github.com/yt-dlp/yt-dlp/issues/544
-    sqlite3 = None
-
-
-try:
-    import websockets
-except ImportError:
-    websockets = None
-
-try:
-    import urllib3
-except ImportError:
-    urllib3 = None
-
-try:
-    import requests
-except ImportError:
-    requests = None
-
-try:
-    import xattr  # xattr or pyxattr
-except ImportError:
-    xattr = None
-else:
-    if hasattr(xattr, 'set'):  # pyxattr
-        xattr._yt_dlp__identifier = 'pyxattr'
-
-
-from . import Cryptodome
-
-all_dependencies = {k: v for k, v in globals().items() if not k.startswith('_')}
-available_dependencies = {k: v for k, v in all_dependencies.items() if v}
-
-
-# Deprecated
-Cryptodome_AES = Cryptodome.AES
-
-
-__all__ = [
-    'all_dependencies',
-    'available_dependencies',
-    *all_dependencies.keys(),
-]

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

@@ -1,131 +0,0 @@
-from ..utils import NO_DEFAULT, determine_protocol
-
-
-def get_suitable_downloader(info_dict, params={}, default=NO_DEFAULT, protocol=None, to_stdout=False):
-    info_dict['protocol'] = determine_protocol(info_dict)
-    info_copy = info_dict.copy()
-    info_copy['to_stdout'] = to_stdout
-
-    protocols = (protocol or info_copy['protocol']).split('+')
-    downloaders = [_get_suitable_downloader(info_copy, proto, params, default) for proto in protocols]
-
-    if set(downloaders) == {FFmpegFD} and FFmpegFD.can_merge_formats(info_copy, params):
-        return FFmpegFD
-    elif (set(downloaders) == {DashSegmentsFD}
-          and not (to_stdout and len(protocols) > 1)
-          and set(protocols) == {'http_dash_segments_generator'}):
-        return DashSegmentsFD
-    elif len(downloaders) == 1:
-        return downloaders[0]
-    return None
-
-
-# Some of these require get_suitable_downloader
-from .common import FileDownloader
-from .dash import DashSegmentsFD
-from .external import FFmpegFD, get_external_downloader
-from .f4m import F4mFD
-from .fc2 import FC2LiveFD
-from .hls import HlsFD
-from .http import HttpFD
-from .ism import IsmFD
-from .mhtml import MhtmlFD
-from .niconico import NiconicoDmcFD, NiconicoLiveFD
-from .rtmp import RtmpFD
-from .rtsp import RtspFD
-from .websocket import WebSocketFragmentFD
-from .youtube_live_chat import YoutubeLiveChatFD
-
-PROTOCOL_MAP = {
-    'rtmp': RtmpFD,
-    'rtmpe': RtmpFD,
-    'rtmp_ffmpeg': FFmpegFD,
-    'm3u8_native': HlsFD,
-    'm3u8': FFmpegFD,
-    'mms': RtspFD,
-    'rtsp': RtspFD,
-    'f4m': F4mFD,
-    'http_dash_segments': DashSegmentsFD,
-    'http_dash_segments_generator': DashSegmentsFD,
-    'ism': IsmFD,
-    'mhtml': MhtmlFD,
-    'niconico_dmc': NiconicoDmcFD,
-    'niconico_live': NiconicoLiveFD,
-    'fc2_live': FC2LiveFD,
-    'websocket_frag': WebSocketFragmentFD,
-    'youtube_live_chat': YoutubeLiveChatFD,
-    'youtube_live_chat_replay': YoutubeLiveChatFD,
-}
-
-
-def shorten_protocol_name(proto, simplify=False):
-    short_protocol_names = {
-        'm3u8_native': 'm3u8',
-        'm3u8': 'm3u8F',
-        'rtmp_ffmpeg': 'rtmpF',
-        'http_dash_segments': 'dash',
-        'http_dash_segments_generator': 'dashG',
-        'niconico_dmc': 'dmc',
-        'websocket_frag': 'WSfrag',
-    }
-    if simplify:
-        short_protocol_names.update({
-            'https': 'http',
-            'ftps': 'ftp',
-            'm3u8': 'm3u8',  # Reverse above m3u8 mapping
-            'm3u8_native': 'm3u8',
-            'http_dash_segments_generator': 'dash',
-            'rtmp_ffmpeg': 'rtmp',
-            'm3u8_frag_urls': 'm3u8',
-            'dash_frag_urls': 'dash',
-        })
-    return short_protocol_names.get(proto, proto)
-
-
-def _get_suitable_downloader(info_dict, protocol, params, default):
-    """Get the downloader class that can handle the info dict."""
-    if default is NO_DEFAULT:
-        default = HttpFD
-
-    if (info_dict.get('section_start') or info_dict.get('section_end')) and FFmpegFD.can_download(info_dict):
-        return FFmpegFD
-
-    info_dict['protocol'] = protocol
-    downloaders = params.get('external_downloader')
-    external_downloader = (
-        downloaders if isinstance(downloaders, str) or downloaders is None
-        else downloaders.get(shorten_protocol_name(protocol, True), downloaders.get('default')))
-
-    if external_downloader is None:
-        if info_dict['to_stdout'] and FFmpegFD.can_merge_formats(info_dict, params):
-            return FFmpegFD
-    elif external_downloader.lower() != 'native':
-        ed = get_external_downloader(external_downloader)
-        if ed.can_download(info_dict, external_downloader):
-            return ed
-
-    if protocol == 'http_dash_segments':
-        if info_dict.get('is_live') and (external_downloader or '').lower() != 'native':
-            return FFmpegFD
-
-    if protocol in ('m3u8', 'm3u8_native'):
-        if info_dict.get('is_live'):
-            return FFmpegFD
-        elif (external_downloader or '').lower() == 'native':
-            return HlsFD
-        elif protocol == 'm3u8_native' and get_suitable_downloader(
-                info_dict, params, None, protocol='m3u8_frag_urls', to_stdout=info_dict['to_stdout']):
-            return HlsFD
-        elif params.get('hls_prefer_native') is True:
-            return HlsFD
-        elif params.get('hls_prefer_native') is False:
-            return FFmpegFD
-
-    return PROTOCOL_MAP.get(protocol, default)
-
-
-__all__ = [
-    'FileDownloader',
-    'get_suitable_downloader',
-    'shorten_protocol_name',
-]