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

@@ -1,164 +0,0 @@
-import collections
-import random
-import urllib.parse
-import urllib.request
-
-from ._utils import remove_start
-
-
-def random_user_agent():
-    _USER_AGENT_TPL = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%s Safari/537.36'
-    _CHROME_VERSIONS = (
-        '90.0.4430.212',
-        '90.0.4430.24',
-        '90.0.4430.70',
-        '90.0.4430.72',
-        '90.0.4430.85',
-        '90.0.4430.93',
-        '91.0.4472.101',
-        '91.0.4472.106',
-        '91.0.4472.114',
-        '91.0.4472.124',
-        '91.0.4472.164',
-        '91.0.4472.19',
-        '91.0.4472.77',
-        '92.0.4515.107',
-        '92.0.4515.115',
-        '92.0.4515.131',
-        '92.0.4515.159',
-        '92.0.4515.43',
-        '93.0.4556.0',
-        '93.0.4577.15',
-        '93.0.4577.63',
-        '93.0.4577.82',
-        '94.0.4606.41',
-        '94.0.4606.54',
-        '94.0.4606.61',
-        '94.0.4606.71',
-        '94.0.4606.81',
-        '94.0.4606.85',
-        '95.0.4638.17',
-        '95.0.4638.50',
-        '95.0.4638.54',
-        '95.0.4638.69',
-        '95.0.4638.74',
-        '96.0.4664.18',
-        '96.0.4664.45',
-        '96.0.4664.55',
-        '96.0.4664.93',
-        '97.0.4692.20',
-    )
-    return _USER_AGENT_TPL % random.choice(_CHROME_VERSIONS)
-
-
-class HTTPHeaderDict(collections.UserDict, dict):
-    """
-    Store and access keys case-insensitively.
-    The constructor can take multiple dicts, in which keys in the latter are prioritised.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-        for dct in args:
-            if dct is not None:
-                self.update(dct)
-        self.update(kwargs)
-
-    def __setitem__(self, key, value):
-        if isinstance(value, bytes):
-            value = value.decode('latin-1')
-        super().__setitem__(key.title(), str(value).strip())
-
-    def __getitem__(self, key):
-        return super().__getitem__(key.title())
-
-    def __delitem__(self, key):
-        super().__delitem__(key.title())
-
-    def __contains__(self, key):
-        return super().__contains__(key.title() if isinstance(key, str) else key)
-
-
-std_headers = HTTPHeaderDict({
-    'User-Agent': random_user_agent(),
-    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-    'Accept-Language': 'en-us,en;q=0.5',
-    'Sec-Fetch-Mode': 'navigate',
-})
-
-
-def clean_proxies(proxies: dict, headers: HTTPHeaderDict):
-    req_proxy = headers.pop('Ytdl-Request-Proxy', None)
-    if req_proxy:
-        proxies.clear()  # XXX: compat: Ytdl-Request-Proxy takes preference over everything, including NO_PROXY
-        proxies['all'] = req_proxy
-    for proxy_key, proxy_url in proxies.items():
-        if proxy_url == '__noproxy__':
-            proxies[proxy_key] = None
-            continue
-        if proxy_key == 'no':  # special case
-            continue
-        if proxy_url is not None:
-            # Ensure proxies without a scheme are http.
-            try:
-                proxy_scheme = urllib.request._parse_proxy(proxy_url)[0]
-            except ValueError:
-                # Ignore invalid proxy URLs. Sometimes these may be introduced through environment
-                # variables unrelated to proxy settings - e.g. Colab `COLAB_LANGUAGE_SERVER_PROXY`.
-                # If the proxy is going to be used, the Request Handler proxy validation will handle it.
-                continue
-            if proxy_scheme is None:
-                proxies[proxy_key] = 'http://' + remove_start(proxy_url, '//')
-
-            replace_scheme = {
-                'socks5': 'socks5h',  # compat: socks5 was treated as socks5h
-                'socks': 'socks4'  # compat: non-standard
-            }
-            if proxy_scheme in replace_scheme:
-                proxies[proxy_key] = urllib.parse.urlunparse(
-                    urllib.parse.urlparse(proxy_url)._replace(scheme=replace_scheme[proxy_scheme]))
-
-
-def clean_headers(headers: HTTPHeaderDict):
-    if 'Youtubedl-No-Compression' in headers:  # compat
-        del headers['Youtubedl-No-Compression']
-        headers['Accept-Encoding'] = 'identity'
-    headers.pop('Ytdl-socks-proxy', None)
-
-
-def remove_dot_segments(path):
-    # Implements RFC3986 5.2.4 remote_dot_segments
-    # Pseudo-code: https://tools.ietf.org/html/rfc3986#section-5.2.4
-    # https://github.com/urllib3/urllib3/blob/ba49f5c4e19e6bca6827282feb77a3c9f937e64b/src/urllib3/util/url.py#L263
-    output = []
-    segments = path.split('/')
-    for s in segments:
-        if s == '.':
-            continue
-        elif s == '..':
-            if output:
-                output.pop()
-        else:
-            output.append(s)
-    if not segments[0] and (not output or output[0]):
-        output.insert(0, '')
-    if segments[-1] in ('.', '..'):
-        output.append('')
-    return '/'.join(output)
-
-
-def escape_rfc3986(s):
-    """Escape non-ASCII characters as suggested by RFC 3986"""
-    return urllib.parse.quote(s, b"%/;:@&=+$,!~*'()?#[]")
-
-
-def normalize_url(url):
-    """Normalize URL as suggested by RFC 3986"""
-    url_parsed = urllib.parse.urlparse(url)
-    return url_parsed._replace(
-        netloc=url_parsed.netloc.encode('idna').decode('ascii'),
-        path=escape_rfc3986(remove_dot_segments(url_parsed.path)),
-        params=escape_rfc3986(url_parsed.params),
-        query=escape_rfc3986(url_parsed.query),
-        fragment=escape_rfc3986(url_parsed.fragment)
-    ).geturl()

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

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-import bisect
-import threading
-import time
-
-
-class ProgressCalculator:
-    # Time to calculate the speed over (seconds)
-    SAMPLING_WINDOW = 3
-    # Minimum timeframe before to sample next downloaded bytes (seconds)
-    SAMPLING_RATE = 0.05
-    # Time before showing eta (seconds)
-    GRACE_PERIOD = 1
-
-    def __init__(self, initial: int):
-        self._initial = initial or 0
-        self.downloaded = self._initial
-
-        self.elapsed: float = 0
-        self.speed = SmoothValue(0, smoothing=0.7)
-        self.eta = SmoothValue(None, smoothing=0.9)
-
-        self._total = 0
-        self._start_time = time.monotonic()
-        self._last_update = self._start_time
-
-        self._lock = threading.Lock()
-        self._thread_sizes: dict[int, int] = {}
-
-        self._times = [self._start_time]
-        self._downloaded = [self.downloaded]
-
-    @property
-    def total(self):
-        return self._total
-
-    @total.setter
-    def total(self, value: int | None):
-        with self._lock:
-            if value is not None and value < self.downloaded:
-                value = self.downloaded
-
-            self._total = value
-
-    def thread_reset(self):
-        current_thread = threading.get_ident()
-        with self._lock:
-            self._thread_sizes[current_thread] = 0
-
-    def update(self, size: int | None):
-        if not size:
-            return
-
-        current_thread = threading.get_ident()
-
-        with self._lock:
-            last_size = self._thread_sizes.get(current_thread, 0)
-            self._thread_sizes[current_thread] = size
-            self._update(size - last_size)
-
-    def _update(self, size: int):
-        current_time = time.monotonic()
-
-        self.downloaded += size
-        self.elapsed = current_time - self._start_time
-        if self.total is not None and self.downloaded > self.total:
-            self._total = self.downloaded
-
-        if self._last_update + self.SAMPLING_RATE > current_time:
-            return
-        self._last_update = current_time
-
-        self._times.append(current_time)
-        self._downloaded.append(self.downloaded)
-
-        offset = bisect.bisect_left(self._times, current_time - self.SAMPLING_WINDOW)
-        del self._times[:offset]
-        del self._downloaded[:offset]
-        if len(self._times) < 2:
-            self.speed.reset()
-            self.eta.reset()
-            return
-
-        download_time = current_time - self._times[0]
-        if not download_time:
-            return
-
-        self.speed.set((self.downloaded - self._downloaded[0]) / download_time)
-        if self.total and self.speed.value and self.elapsed > self.GRACE_PERIOD:
-            self.eta.set((self.total - self.downloaded) / self.speed.value)
-        else:
-            self.eta.reset()
-
-
-class SmoothValue:
-    def __init__(self, initial: float | None, smoothing: float):
-        self.value = self.smooth = self._initial = initial
-        self._smoothing = smoothing
-
-    def set(self, value: float):
-        self.value = value
-        if self.smooth is None:
-            self.smooth = self.value
-        else:
-            self.smooth = (1 - self._smoothing) * value + self._smoothing * self.smooth
-
-    def reset(self):
-        self.value = self.smooth = self._initial

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

@@ -1,276 +0,0 @@
-import collections.abc
-import contextlib
-import inspect
-import itertools
-import re
-import xml.etree.ElementTree
-
-from ._utils import (
-    IDENTITY,
-    NO_DEFAULT,
-    LazyList,
-    deprecation_warning,
-    is_iterable_like,
-    try_call,
-    variadic,
-)
-
-
-def traverse_obj(
-        obj, *paths, default=NO_DEFAULT, expected_type=None, get_all=True,
-        casesense=True, is_user_input=NO_DEFAULT, traverse_string=False):
-    """
-    Safely traverse nested `dict`s and `Iterable`s
-
-    >>> obj = [{}, {"key": "value"}]
-    >>> traverse_obj(obj, (1, "key"))
-    'value'
-
-    Each of the provided `paths` is tested and the first producing a valid result will be returned.
-    The next path will also be tested if the path branched but no results could be found.
-    Supported values for traversal are `Mapping`, `Iterable` and `re.Match`.
-    Unhelpful values (`{}`, `None`) are treated as the absence of a value and discarded.
-
-    The paths will be wrapped in `variadic`, so that `'key'` is conveniently the same as `('key', )`.
-
-    The keys in the path can be one of:
-        - `None`:           Return the current object.
-        - `set`:            Requires the only item in the set to be a type or function,
-                            like `{type}`/`{func}`. If a `type`, returns only values
-                            of this type. If a function, returns `func(obj)`.
-        - `str`/`int`:      Return `obj[key]`. For `re.Match`, return `obj.group(key)`.
-        - `slice`:          Branch out and return all values in `obj[key]`.
-        - `Ellipsis`:       Branch out and return a list of all values.
-        - `tuple`/`list`:   Branch out and return a list of all matching values.
-                            Read as: `[traverse_obj(obj, branch) for branch in branches]`.
-        - `function`:       Branch out and return values filtered by the function.
-                            Read as: `[value for key, value in obj if function(key, value)]`.
-                            For `Iterable`s, `key` is the index of the value.
-                            For `re.Match`es, `key` is the group number (0 = full match)
-                            as well as additionally any group names, if given.
-        - `dict`            Transform the current object and return a matching dict.
-                            Read as: `{key: traverse_obj(obj, path) for key, path in dct.items()}`.
-
-        `tuple`, `list`, and `dict` all support nested paths and branches.
-
-    @params paths           Paths which to traverse by.
-    @param default          Value to return if the paths do not match.
-                            If the last key in the path is a `dict`, it will apply to each value inside
-                            the dict instead, depth first. Try to avoid if using nested `dict` keys.
-    @param expected_type    If a `type`, only accept final values of this type.
-                            If any other callable, try to call the function on each result.
-                            If the last key in the path is a `dict`, it will apply to each value inside
-                            the dict instead, recursively. This does respect branching paths.
-    @param get_all          If `False`, return the first matching result, otherwise all matching ones.
-    @param casesense        If `False`, consider string dictionary keys as case insensitive.
-
-    `traverse_string` is only meant to be used by YoutubeDL.prepare_outtmpl and is not part of the API
-
-    @param traverse_string  Whether to traverse into objects as strings.
-                            If `True`, any non-compatible object will first be
-                            converted into a string and then traversed into.
-                            The return value of that path will be a string instead,
-                            not respecting any further branching.
-
-
-    @returns                The result of the object traversal.
-                            If successful, `get_all=True`, and the path branches at least once,
-                            then a list of results is returned instead.
-                            If no `default` is given and the last path branches, a `list` of results
-                            is always returned. If a path ends on a `dict` that result will always be a `dict`.
-    """
-    if is_user_input is not NO_DEFAULT:
-        deprecation_warning('The is_user_input parameter is deprecated and no longer works')
-
-    casefold = lambda k: k.casefold() if isinstance(k, str) else k
-
-    if isinstance(expected_type, type):
-        type_test = lambda val: val if isinstance(val, expected_type) else None
-    else:
-        type_test = lambda val: try_call(expected_type or IDENTITY, args=(val,))
-
-    def apply_key(key, obj, is_last):
-        branching = False
-        result = None
-
-        if obj is None and traverse_string:
-            if key is ... or callable(key) or isinstance(key, slice):
-                branching = True
-                result = ()
-
-        elif key is None:
-            result = obj
-
-        elif isinstance(key, set):
-            assert len(key) == 1, 'Set should only be used to wrap a single item'
-            item = next(iter(key))
-            if isinstance(item, type):
-                if isinstance(obj, item):
-                    result = obj
-            else:
-                result = try_call(item, args=(obj,))
-
-        elif isinstance(key, (list, tuple)):
-            branching = True
-            result = itertools.chain.from_iterable(
-                apply_path(obj, branch, is_last)[0] for branch in key)
-
-        elif key is ...:
-            branching = True
-            if isinstance(obj, collections.abc.Mapping):
-                result = obj.values()
-            elif is_iterable_like(obj) or isinstance(obj, xml.etree.ElementTree.Element):
-                result = obj
-            elif isinstance(obj, re.Match):
-                result = obj.groups()
-            elif traverse_string:
-                branching = False
-                result = str(obj)
-            else:
-                result = ()
-
-        elif callable(key):
-            branching = True
-            if isinstance(obj, collections.abc.Mapping):
-                iter_obj = obj.items()
-            elif is_iterable_like(obj) or isinstance(obj, xml.etree.ElementTree.Element):
-                iter_obj = enumerate(obj)
-            elif isinstance(obj, re.Match):
-                iter_obj = itertools.chain(
-                    enumerate((obj.group(), *obj.groups())),
-                    obj.groupdict().items())
-            elif traverse_string:
-                branching = False
-                iter_obj = enumerate(str(obj))
-            else:
-                iter_obj = ()
-
-            result = (v for k, v in iter_obj if try_call(key, args=(k, v)))
-            if not branching:  # string traversal
-                result = ''.join(result)
-
-        elif isinstance(key, dict):
-            iter_obj = ((k, _traverse_obj(obj, v, False, is_last)) for k, v in key.items())
-            result = {
-                k: v if v is not None else default for k, v in iter_obj
-                if v is not None or default is not NO_DEFAULT
-            } or None
-
-        elif isinstance(obj, collections.abc.Mapping):
-            result = (try_call(obj.get, args=(key,)) if casesense or try_call(obj.__contains__, args=(key,)) else
-                      next((v for k, v in obj.items() if casefold(k) == key), None))
-
-        elif isinstance(obj, re.Match):
-            if isinstance(key, int) or casesense:
-                with contextlib.suppress(IndexError):
-                    result = obj.group(key)
-
-            elif isinstance(key, str):
-                result = next((v for k, v in obj.groupdict().items() if casefold(k) == key), None)
-
-        elif isinstance(key, (int, slice)):
-            if is_iterable_like(obj, (collections.abc.Sequence, xml.etree.ElementTree.Element)):
-                branching = isinstance(key, slice)
-                with contextlib.suppress(IndexError):
-                    result = obj[key]
-            elif traverse_string:
-                with contextlib.suppress(IndexError):
-                    result = str(obj)[key]
-
-        elif isinstance(obj, xml.etree.ElementTree.Element) and isinstance(key, str):
-            xpath, _, special = key.rpartition('/')
-            if not special.startswith('@') and special != 'text()':
-                xpath = key
-                special = None
-
-            # Allow abbreviations of relative paths, absolute paths error
-            if xpath.startswith('/'):
-                xpath = f'.{xpath}'
-            elif xpath and not xpath.startswith('./'):
-                xpath = f'./{xpath}'
-
-            def apply_specials(element):
-                if special is None:
-                    return element
-                if special == '@':
-                    return element.attrib
-                if special.startswith('@'):
-                    return try_call(element.attrib.get, args=(special[1:],))
-                if special == 'text()':
-                    return element.text
-                assert False, f'apply_specials is missing case for {special!r}'
-
-            if xpath:
-                result = list(map(apply_specials, obj.iterfind(xpath)))
-            else:
-                result = apply_specials(obj)
-
-        return branching, result if branching else (result,)
-
-    def lazy_last(iterable):
-        iterator = iter(iterable)
-        prev = next(iterator, NO_DEFAULT)
-        if prev is NO_DEFAULT:
-            return
-
-        for item in iterator:
-            yield False, prev
-            prev = item
-
-        yield True, prev
-
-    def apply_path(start_obj, path, test_type):
-        objs = (start_obj,)
-        has_branched = False
-
-        key = None
-        for last, key in lazy_last(variadic(path, (str, bytes, dict, set))):
-            if not casesense and isinstance(key, str):
-                key = key.casefold()
-
-            if __debug__ and callable(key):
-                # Verify function signature
-                inspect.signature(key).bind(None, None)
-
-            new_objs = []
-            for obj in objs:
-                branching, results = apply_key(key, obj, last)
-                has_branched |= branching
-                new_objs.append(results)
-
-            objs = itertools.chain.from_iterable(new_objs)
-
-        if test_type and not isinstance(key, (dict, list, tuple)):
-            objs = map(type_test, objs)
-
-        return objs, has_branched, isinstance(key, dict)
-
-    def _traverse_obj(obj, path, allow_empty, test_type):
-        results, has_branched, is_dict = apply_path(obj, path, test_type)
-        results = LazyList(item for item in results if item not in (None, {}))
-        if get_all and has_branched:
-            if results:
-                return results.exhaust()
-            if allow_empty:
-                return [] if default is NO_DEFAULT else default
-            return None
-
-        return results[0] if results else {} if allow_empty and is_dict else None
-
-    for index, path in enumerate(paths, 1):
-        result = _traverse_obj(obj, path, index == len(paths), True)
-        if result is not None:
-            return result
-
-    return None if default is NO_DEFAULT else default
-
-
-def get_first(obj, *paths, **kwargs):
-    return traverse_obj(obj, *((..., *variadic(keys)) for keys in paths), **kwargs, get_all=False)
-
-
-def dict_get(d, key_or_keys, default=None, skip_false_values=True):
-    for val in map(d.get, variadic(key_or_keys)):
-        if val is not None and (val or not skip_false_values):
-            return val
-    return default

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

@@ -1,15 +0,0 @@
-# Autogenerated by devscripts/update-version.py
-
-__version__ = '2024.03.10'
-
-RELEASE_GIT_HEAD = '615a84447e8322720be77a0e64298d7f42848693'
-
-VARIANT = 'pip'
-
-UPDATE_HINT = 'You installed yt-dlp with pip or using the wheel from PyPi; Use that to update'
-
-CHANNEL = 'stable'
-
-ORIGIN = 'yt-dlp/yt-dlp'
-
-_pkg_version = '2024.03.10'