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

@@ -1,176 +0,0 @@
-import contextlib
-import importlib
-import importlib.abc
-import importlib.machinery
-import importlib.util
-import inspect
-import itertools
-import pkgutil
-import sys
-import traceback
-import zipimport
-from pathlib import Path
-from zipfile import ZipFile
-
-from .compat import functools  # isort: split
-from .utils import (
-    get_executable_path,
-    get_system_config_dirs,
-    get_user_config_dirs,
-    orderedSet,
-    write_string,
-)
-
-PACKAGE_NAME = 'yt_dlp_plugins'
-COMPAT_PACKAGE_NAME = 'ytdlp_plugins'
-
-
-class PluginLoader(importlib.abc.Loader):
-    """Dummy loader for virtual namespace packages"""
-
-    def exec_module(self, module):
-        return None
-
-
-@functools.cache
-def dirs_in_zip(archive):
-    try:
-        with ZipFile(archive) as zip_:
-            return set(itertools.chain.from_iterable(
-                Path(file).parents for file in zip_.namelist()))
-    except FileNotFoundError:
-        pass
-    except Exception as e:
-        write_string(f'WARNING: Could not read zip file {archive}: {e}\n')
-    return set()
-
-
-class PluginFinder(importlib.abc.MetaPathFinder):
-    """
-    This class provides one or multiple namespace packages.
-    It searches in sys.path and yt-dlp config folders for
-    the existing subdirectories from which the modules can be imported
-    """
-
-    def __init__(self, *packages):
-        self._zip_content_cache = {}
-        self.packages = set(itertools.chain.from_iterable(
-            itertools.accumulate(name.split('.'), lambda a, b: '.'.join((a, b)))
-            for name in packages))
-
-    def search_locations(self, fullname):
-        candidate_locations = []
-
-        def _get_package_paths(*root_paths, containing_folder='plugins'):
-            for config_dir in orderedSet(map(Path, root_paths), lazy=True):
-                with contextlib.suppress(OSError):
-                    yield from (config_dir / containing_folder).iterdir()
-
-        # Load from yt-dlp config folders
-        candidate_locations.extend(_get_package_paths(
-            *get_user_config_dirs('yt-dlp'),
-            *get_system_config_dirs('yt-dlp'),
-            containing_folder='plugins'))
-
-        # Load from yt-dlp-plugins folders
-        candidate_locations.extend(_get_package_paths(
-            get_executable_path(),
-            *get_user_config_dirs(''),
-            *get_system_config_dirs(''),
-            containing_folder='yt-dlp-plugins'))
-
-        candidate_locations.extend(map(Path, sys.path))  # PYTHONPATH
-        with contextlib.suppress(ValueError):  # Added when running __main__.py directly
-            candidate_locations.remove(Path(__file__).parent)
-
-        parts = Path(*fullname.split('.'))
-        for path in orderedSet(candidate_locations, lazy=True):
-            candidate = path / parts
-            try:
-                if candidate.is_dir():
-                    yield candidate
-                elif path.suffix in ('.zip', '.egg', '.whl') and path.is_file():
-                    if parts in dirs_in_zip(path):
-                        yield candidate
-            except PermissionError as e:
-                write_string(f'Permission error while accessing modules in "{e.filename}"\n')
-
-    def find_spec(self, fullname, path=None, target=None):
-        if fullname not in self.packages:
-            return None
-
-        search_locations = list(map(str, self.search_locations(fullname)))
-        if not search_locations:
-            return None
-
-        spec = importlib.machinery.ModuleSpec(fullname, PluginLoader(), is_package=True)
-        spec.submodule_search_locations = search_locations
-        return spec
-
-    def invalidate_caches(self):
-        dirs_in_zip.cache_clear()
-        for package in self.packages:
-            if package in sys.modules:
-                del sys.modules[package]
-
-
-def directories():
-    spec = importlib.util.find_spec(PACKAGE_NAME)
-    return spec.submodule_search_locations if spec else []
-
-
-def iter_modules(subpackage):
-    fullname = f'{PACKAGE_NAME}.{subpackage}'
-    with contextlib.suppress(ModuleNotFoundError):
-        pkg = importlib.import_module(fullname)
-        yield from pkgutil.iter_modules(path=pkg.__path__, prefix=f'{fullname}.')
-
-
-def load_module(module, module_name, suffix):
-    return inspect.getmembers(module, lambda obj: (
-        inspect.isclass(obj)
-        and obj.__name__.endswith(suffix)
-        and obj.__module__.startswith(module_name)
-        and not obj.__name__.startswith('_')
-        and obj.__name__ in getattr(module, '__all__', [obj.__name__])))
-
-
-def load_plugins(name, suffix):
-    classes = {}
-
-    for finder, module_name, _ in iter_modules(name):
-        if any(x.startswith('_') for x in module_name.split('.')):
-            continue
-        try:
-            if sys.version_info < (3, 10) and isinstance(finder, zipimport.zipimporter):
-                # zipimporter.load_module() is deprecated in 3.10 and removed in 3.12
-                # The exec_module branch below is the replacement for >= 3.10
-                # See: https://docs.python.org/3/library/zipimport.html#zipimport.zipimporter.exec_module
-                module = finder.load_module(module_name)
-            else:
-                spec = finder.find_spec(module_name)
-                module = importlib.util.module_from_spec(spec)
-                sys.modules[module_name] = module
-                spec.loader.exec_module(module)
-        except Exception:
-            write_string(f'Error while importing module {module_name!r}\n{traceback.format_exc(limit=-1)}')
-            continue
-        classes.update(load_module(module, module_name, suffix))
-
-    # Compat: old plugin system using __init__.py
-    # Note: plugins imported this way do not show up in directories()
-    # nor are considered part of the yt_dlp_plugins namespace package
-    with contextlib.suppress(FileNotFoundError):
-        spec = importlib.util.spec_from_file_location(
-            name, Path(get_executable_path(), COMPAT_PACKAGE_NAME, name, '__init__.py'))
-        plugins = importlib.util.module_from_spec(spec)
-        sys.modules[spec.name] = plugins
-        spec.loader.exec_module(plugins)
-        classes.update(load_module(plugins, spec.name, suffix))
-
-    return classes
-
-
-sys.meta_path.insert(0, PluginFinder(f'{PACKAGE_NAME}.extractor', f'{PACKAGE_NAME}.postprocessor'))
-
-__all__ = ['directories', 'load_plugins', 'PACKAGE_NAME', 'COMPAT_PACKAGE_NAME']

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

@@ -1,47 +0,0 @@
-# flake8: noqa: F401
-
-from .common import PostProcessor
-from .embedthumbnail import EmbedThumbnailPP
-from .exec import ExecAfterDownloadPP, ExecPP
-from .ffmpeg import (
-    FFmpegConcatPP,
-    FFmpegCopyStreamPP,
-    FFmpegEmbedSubtitlePP,
-    FFmpegExtractAudioPP,
-    FFmpegFixupDuplicateMoovPP,
-    FFmpegFixupDurationPP,
-    FFmpegFixupM3u8PP,
-    FFmpegFixupM4aPP,
-    FFmpegFixupStretchedPP,
-    FFmpegFixupTimestampPP,
-    FFmpegMergerPP,
-    FFmpegMetadataPP,
-    FFmpegPostProcessor,
-    FFmpegSplitChaptersPP,
-    FFmpegSubtitlesConvertorPP,
-    FFmpegThumbnailsConvertorPP,
-    FFmpegVideoConvertorPP,
-    FFmpegVideoRemuxerPP,
-)
-from .metadataparser import (
-    MetadataFromFieldPP,
-    MetadataFromTitlePP,
-    MetadataParserPP,
-)
-from .modify_chapters import ModifyChaptersPP
-from .movefilesafterdownload import MoveFilesAfterDownloadPP
-from .sponskrub import SponSkrubPP
-from .sponsorblock import SponsorBlockPP
-from .xattrpp import XAttrMetadataPP
-from ..plugins import load_plugins
-
-_PLUGIN_CLASSES = load_plugins('postprocessor', 'PP')
-
-
-def get_postprocessor(key):
-    return globals()[key + 'PP']
-
-
-globals().update(_PLUGIN_CLASSES)
-__all__ = [name for name in globals().keys() if name.endswith('PP')]
-__all__.extend(('PostProcessor', 'FFmpegPostProcessor'))

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

@@ -1,215 +0,0 @@
-import functools
-import json
-import os
-
-from ..networking import Request
-from ..networking.exceptions import HTTPError, network_exceptions
-from ..utils import (
-    PostProcessingError,
-    RetryManager,
-    _configuration_args,
-    deprecation_warning,
-    encodeFilename,
-)
-
-
-class PostProcessorMetaClass(type):
-    @staticmethod
-    def run_wrapper(func):
-        @functools.wraps(func)
-        def run(self, info, *args, **kwargs):
-            info_copy = self._copy_infodict(info)
-            self._hook_progress({'status': 'started'}, info_copy)
-            ret = func(self, info, *args, **kwargs)
-            if ret is not None:
-                _, info = ret
-            self._hook_progress({'status': 'finished'}, info_copy)
-            return ret
-        return run
-
-    def __new__(cls, name, bases, attrs):
-        if 'run' in attrs:
-            attrs['run'] = cls.run_wrapper(attrs['run'])
-        return type.__new__(cls, name, bases, attrs)
-
-
-class PostProcessor(metaclass=PostProcessorMetaClass):
-    """Post Processor class.
-
-    PostProcessor objects can be added to downloaders with their
-    add_post_processor() method. When the downloader has finished a
-    successful download, it will take its internal chain of PostProcessors
-    and start calling the run() method on each one of them, first with
-    an initial argument and then with the returned value of the previous
-    PostProcessor.
-
-    PostProcessor objects follow a "mutual registration" process similar
-    to InfoExtractor objects.
-
-    Optionally PostProcessor can use a list of additional command-line arguments
-    with self._configuration_args.
-    """
-
-    _downloader = None
-
-    def __init__(self, downloader=None):
-        self._progress_hooks = []
-        self.add_progress_hook(self.report_progress)
-        self.set_downloader(downloader)
-        self.PP_NAME = self.pp_key()
-
-    @classmethod
-    def pp_key(cls):
-        name = cls.__name__[:-2]
-        return name[6:] if name[:6].lower() == 'ffmpeg' else name
-
-    def to_screen(self, text, prefix=True, *args, **kwargs):
-        if self._downloader:
-            tag = '[%s] ' % self.PP_NAME if prefix else ''
-            return self._downloader.to_screen(f'{tag}{text}', *args, **kwargs)
-
-    def report_warning(self, text, *args, **kwargs):
-        if self._downloader:
-            return self._downloader.report_warning(text, *args, **kwargs)
-
-    def deprecation_warning(self, msg):
-        warn = getattr(self._downloader, 'deprecation_warning', deprecation_warning)
-        return warn(msg, stacklevel=1)
-
-    def deprecated_feature(self, msg):
-        if self._downloader:
-            return self._downloader.deprecated_feature(msg)
-        return deprecation_warning(msg, stacklevel=1)
-
-    def report_error(self, text, *args, **kwargs):
-        self.deprecation_warning('"yt_dlp.postprocessor.PostProcessor.report_error" is deprecated. '
-                                 'raise "yt_dlp.utils.PostProcessingError" instead')
-        if self._downloader:
-            return self._downloader.report_error(text, *args, **kwargs)
-
-    def write_debug(self, text, *args, **kwargs):
-        if self._downloader:
-            return self._downloader.write_debug(text, *args, **kwargs)
-
-    def _delete_downloaded_files(self, *files_to_delete, **kwargs):
-        if self._downloader:
-            return self._downloader._delete_downloaded_files(*files_to_delete, **kwargs)
-        for filename in set(filter(None, files_to_delete)):
-            os.remove(filename)
-
-    def get_param(self, name, default=None, *args, **kwargs):
-        if self._downloader:
-            return self._downloader.params.get(name, default, *args, **kwargs)
-        return default
-
-    def set_downloader(self, downloader):
-        """Sets the downloader for this PP."""
-        self._downloader = downloader
-        for ph in getattr(downloader, '_postprocessor_hooks', []):
-            self.add_progress_hook(ph)
-
-    def _copy_infodict(self, info_dict):
-        return getattr(self._downloader, '_copy_infodict', dict)(info_dict)
-
-    @staticmethod
-    def _restrict_to(*, video=True, audio=True, images=True, simulated=True):
-        allowed = {'video': video, 'audio': audio, 'images': images}
-
-        def decorator(func):
-            @functools.wraps(func)
-            def wrapper(self, info):
-                if not simulated and (self.get_param('simulate') or self.get_param('skip_download')):
-                    return [], info
-                format_type = (
-                    'video' if info.get('vcodec') != 'none'
-                    else 'audio' if info.get('acodec') != 'none'
-                    else 'images')
-                if allowed[format_type]:
-                    return func(self, info)
-                else:
-                    self.to_screen('Skipping %s' % format_type)
-                    return [], info
-            return wrapper
-        return decorator
-
-    def run(self, information):
-        """Run the PostProcessor.
-
-        The "information" argument is a dictionary like the ones
-        composed by InfoExtractors. The only difference is that this
-        one has an extra field called "filepath" that points to the
-        downloaded file.
-
-        This method returns a tuple, the first element is a list of the files
-        that can be deleted, and the second of which is the updated
-        information.
-
-        In addition, this method may raise a PostProcessingError
-        exception if post processing fails.
-        """
-        return [], information  # by default, keep file and do nothing
-
-    def try_utime(self, path, atime, mtime, errnote='Cannot update utime of file'):
-        try:
-            os.utime(encodeFilename(path), (atime, mtime))
-        except Exception:
-            self.report_warning(errnote)
-
-    def _configuration_args(self, exe, *args, **kwargs):
-        return _configuration_args(
-            self.pp_key(), self.get_param('postprocessor_args'), exe, *args, **kwargs)
-
-    def _hook_progress(self, status, info_dict):
-        if not self._progress_hooks:
-            return
-        status.update({
-            'info_dict': info_dict,
-            'postprocessor': self.pp_key(),
-        })
-        for ph in self._progress_hooks:
-            ph(status)
-
-    def add_progress_hook(self, ph):
-        # See YoutubeDl.py (search for postprocessor_hooks) for a description of this interface
-        self._progress_hooks.append(ph)
-
-    def report_progress(self, s):
-        s['_default_template'] = '%(postprocessor)s %(status)s' % s
-        if not self._downloader:
-            return
-
-        progress_dict = s.copy()
-        progress_dict.pop('info_dict')
-        progress_dict = {'info': s['info_dict'], 'progress': progress_dict}
-
-        progress_template = self.get_param('progress_template', {})
-        tmpl = progress_template.get('postprocess')
-        if tmpl:
-            self._downloader.to_screen(
-                self._downloader.evaluate_outtmpl(tmpl, progress_dict), quiet=False)
-
-        self._downloader.to_console_title(self._downloader.evaluate_outtmpl(
-            progress_template.get('postprocess-title') or 'yt-dlp %(progress._default_template)s',
-            progress_dict))
-
-    def _retry_download(self, err, count, retries):
-        # While this is not an extractor, it behaves similar to one and
-        # so obey extractor_retries and "--retry-sleep extractor"
-        RetryManager.report_retry(err, count, retries, info=self.to_screen, warn=self.report_warning,
-                                  sleep_func=self.get_param('retry_sleep_functions', {}).get('extractor'))
-
-    def _download_json(self, url, *, expected_http_errors=(404,)):
-        self.write_debug(f'{self.PP_NAME} query: {url}')
-        for retry in RetryManager(self.get_param('extractor_retries', 3), self._retry_download):
-            try:
-                rsp = self._downloader.urlopen(Request(url))
-            except network_exceptions as e:
-                if isinstance(e, HTTPError) and e.status in expected_http_errors:
-                    return None
-                retry.error = PostProcessingError(f'Unable to communicate with {self.PP_NAME} API: {e}')
-                continue
-        return json.loads(rsp.read().decode(rsp.headers.get_param('charset') or 'utf-8'))
-
-
-class AudioConversionError(PostProcessingError):  # Deprecated
-    pass