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

@@ -1,15 +0,0 @@
-from typing import Any, Callable, Optional
-
-
-class Monostate:
-    def __init__(
-        self,
-        on_progress: Optional[Callable[[Any, bytes, int], None]],
-        on_complete: Optional[Callable[[Any, Optional[str]], None]],
-        title: Optional[str] = None,
-        duration: Optional[int] = None,
-    ):
-        self.on_progress = on_progress
-        self.on_complete = on_complete
-        self.title = title
-        self.duration = duration

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

@@ -1,185 +0,0 @@
-import ast
-import json
-import re
-from pytube.exceptions import HTMLParseError
-
-
-def parse_for_all_objects(html, preceding_regex):
-    """Parses input html to find all matches for the input starting point.
-
-    :param str html:
-        HTML to be parsed for an object.
-    :param str preceding_regex:
-        Regex to find the string preceding the object.
-    :rtype list:
-    :returns:
-        A list of dicts created from parsing the objects.
-    """
-    result = []
-    regex = re.compile(preceding_regex)
-    match_iter = regex.finditer(html)
-    for match in match_iter:
-        if match:
-            start_index = match.end()
-            try:
-                obj = parse_for_object_from_startpoint(html, start_index)
-            except HTMLParseError:
-                # Some of the instances might fail because set is technically
-                # a method of the ytcfg object. We'll skip these since they
-                # don't seem relevant at the moment.
-                continue
-            else:
-                result.append(obj)
-
-    if len(result) == 0:
-        raise HTMLParseError(f'No matches for regex {preceding_regex}')
-
-    return result
-
-
-def parse_for_object(html, preceding_regex):
-    """Parses input html to find the end of a JavaScript object.
-
-    :param str html:
-        HTML to be parsed for an object.
-    :param str preceding_regex:
-        Regex to find the string preceding the object.
-    :rtype dict:
-    :returns:
-        A dict created from parsing the object.
-    """
-    regex = re.compile(preceding_regex)
-    result = regex.search(html)
-    if not result:
-        raise HTMLParseError(f'No matches for regex {preceding_regex}')
-
-    start_index = result.end()
-    return parse_for_object_from_startpoint(html, start_index)
-
-
-def find_object_from_startpoint(html, start_point):
-    """Parses input html to find the end of a JavaScript object.
-
-    :param str html:
-        HTML to be parsed for an object.
-    :param int start_point:
-        Index of where the object starts.
-    :rtype dict:
-    :returns:
-        A dict created from parsing the object.
-    """
-    html = html[start_point:]
-    if html[0] not in ['{','[']:
-        raise HTMLParseError(f'Invalid start point. Start of HTML:\n{html[:20]}')
-
-    # First letter MUST be a open brace, so we put that in the stack,
-    # and skip the first character.
-    last_char = '{'
-    curr_char = None
-    stack = [html[0]]
-    i = 1
-
-    context_closers = {
-        '{': '}',
-        '[': ']',
-        '"': '"',
-        '/': '/' # javascript regex
-    }
-
-    while i < len(html):
-        if len(stack) == 0:
-            break
-        if curr_char not in [' ', '\n']:
-            last_char = curr_char
-        curr_char = html[i]
-        curr_context = stack[-1]
-
-        # If we've reached a context closer, we can remove an element off the stack
-        if curr_char == context_closers[curr_context]:
-            stack.pop()
-            i += 1
-            continue
-
-        # Strings and regex expressions require special context handling because they can contain
-        #  context openers *and* closers
-        if curr_context in ['"', '/']:
-            # If there's a backslash in a string or regex expression, we skip a character
-            if curr_char == '\\':
-                i += 2
-                continue
-        else:
-            # Non-string contexts are when we need to look for context openers.
-            if curr_char in context_closers.keys():
-                # Slash starts a regular expression depending on context
-                if not (curr_char == '/' and last_char not in ['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';']): 
-                    stack.append(curr_char)
-
-        i += 1
-
-    full_obj = html[:i]
-    return full_obj  # noqa: R504
-
-
-def parse_for_object_from_startpoint(html, start_point):
-    """JSONifies an object parsed from HTML.
-
-    :param str html:
-        HTML to be parsed for an object.
-    :param int start_point:
-        Index of where the object starts.
-    :rtype dict:
-    :returns:
-        A dict created from parsing the object.
-    """
-    full_obj = find_object_from_startpoint(html, start_point)
-    try:
-        return json.loads(full_obj)
-    except json.decoder.JSONDecodeError:
-        try:
-            return ast.literal_eval(full_obj)
-        except (ValueError, SyntaxError):
-            raise HTMLParseError('Could not parse object.')
-
-
-def throttling_array_split(js_array):
-    """Parses the throttling array into a python list of strings.
-
-    Expects input to begin with `[` and close with `]`.
-
-    :param str js_array:
-        The javascript array, as a string.
-    :rtype: list:
-    :returns:
-        A list of strings representing splits on `,` in the throttling array.
-    """
-    results = []
-    curr_substring = js_array[1:]
-
-    comma_regex = re.compile(r",")
-    func_regex = re.compile(r"function\([^)]*\)")
-
-    while len(curr_substring) > 0:
-        if curr_substring.startswith('function'):
-            # Handle functions separately. These can contain commas
-            match = func_regex.search(curr_substring)
-            match_start, match_end = match.span()
-
-            function_text = find_object_from_startpoint(curr_substring, match.span()[1])
-            full_function_def = curr_substring[:match_end + len(function_text)]
-            results.append(full_function_def)
-            curr_substring = curr_substring[len(full_function_def) + 1:]
-        else:
-            match = comma_regex.search(curr_substring)
-
-            # Try-catch to capture end of array
-            try:
-                match_start, match_end = match.span()
-            except AttributeError:
-                match_start = len(curr_substring) - 1
-                match_end = match_start + 1
-
-            curr_el = curr_substring[:match_start]
-            results.append(curr_el)
-            curr_substring = curr_substring[match_end:]
-
-    return results

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

@@ -1,424 +0,0 @@
-"""This module provides a query interface for media streams and captions."""
-from collections.abc import Mapping, Sequence
-from typing import Callable, List, Optional, Union
-
-from pytube import Caption, Stream
-from pytube.helpers import deprecated
-
-
-class StreamQuery(Sequence):
-    """Interface for querying the available media streams."""
-
-    def __init__(self, fmt_streams):
-        """Construct a :class:`StreamQuery <StreamQuery>`.
-
-        param list fmt_streams:
-            list of :class:`Stream <Stream>` instances.
-        """
-        self.fmt_streams = fmt_streams
-        self.itag_index = {int(s.itag): s for s in fmt_streams}
-
-    def filter(
-        self,
-        fps=None,
-        res=None,
-        resolution=None,
-        mime_type=None,
-        type=None,
-        subtype=None,
-        file_extension=None,
-        abr=None,
-        bitrate=None,
-        video_codec=None,
-        audio_codec=None,
-        only_audio=None,
-        only_video=None,
-        progressive=None,
-        adaptive=None,
-        is_dash=None,
-        custom_filter_functions=None,
-    ):
-        """Apply the given filtering criterion.
-
-        :param fps:
-            (optional) The frames per second.
-        :type fps:
-            int or None
-
-        :param resolution:
-            (optional) Alias to ``res``.
-        :type res:
-            str or None
-
-        :param res:
-            (optional) The video resolution.
-        :type resolution:
-            str or None
-
-        :param mime_type:
-            (optional) Two-part identifier for file formats and format contents
-            composed of a "type", a "subtype".
-        :type mime_type:
-            str or None
-
-        :param type:
-            (optional) Type part of the ``mime_type`` (e.g.: audio, video).
-        :type type:
-            str or None
-
-        :param subtype:
-            (optional) Sub-type part of the ``mime_type`` (e.g.: mp4, mov).
-        :type subtype:
-            str or None
-
-        :param file_extension:
-            (optional) Alias to ``sub_type``.
-        :type file_extension:
-            str or None
-
-        :param abr:
-            (optional) Average bitrate (ABR) refers to the average amount of
-            data transferred per unit of time (e.g.: 64kbps, 192kbps).
-        :type abr:
-            str or None
-
-        :param bitrate:
-            (optional) Alias to ``abr``.
-        :type bitrate:
-            str or None
-
-        :param video_codec:
-            (optional) Video compression format.
-        :type video_codec:
-            str or None
-
-        :param audio_codec:
-            (optional) Audio compression format.
-        :type audio_codec:
-            str or None
-
-        :param bool progressive:
-            Excludes adaptive streams (one file contains both audio and video
-            tracks).
-
-        :param bool adaptive:
-            Excludes progressive streams (audio and video are on separate
-            tracks).
-
-        :param bool is_dash:
-            Include/exclude dash streams.
-
-        :param bool only_audio:
-            Excludes streams with video tracks.
-
-        :param bool only_video:
-            Excludes streams with audio tracks.
-
-        :param custom_filter_functions:
-            (optional) Interface for defining complex filters without
-            subclassing.
-        :type custom_filter_functions:
-            list or None
-
-        """
-        filters = []
-        if res or resolution:
-            if isinstance(res, str) or isinstance(resolution, str):
-                filters.append(lambda s: s.resolution == (res or resolution))
-            elif isinstance(res, list) or isinstance(resolution, list):
-                filters.append(lambda s: s.resolution in (res or resolution))
-
-        if fps:
-            filters.append(lambda s: s.fps == fps)
-
-        if mime_type:
-            filters.append(lambda s: s.mime_type == mime_type)
-
-        if type:
-            filters.append(lambda s: s.type == type)
-
-        if subtype or file_extension:
-            filters.append(lambda s: s.subtype == (subtype or file_extension))
-
-        if abr or bitrate:
-            filters.append(lambda s: s.abr == (abr or bitrate))
-
-        if video_codec:
-            filters.append(lambda s: s.video_codec == video_codec)
-
-        if audio_codec:
-            filters.append(lambda s: s.audio_codec == audio_codec)
-
-        if only_audio:
-            filters.append(
-                lambda s: (
-                    s.includes_audio_track and not s.includes_video_track
-                ),
-            )
-
-        if only_video:
-            filters.append(
-                lambda s: (
-                    s.includes_video_track and not s.includes_audio_track
-                ),
-            )
-
-        if progressive:
-            filters.append(lambda s: s.is_progressive)
-
-        if adaptive:
-            filters.append(lambda s: s.is_adaptive)
-
-        if custom_filter_functions:
-            filters.extend(custom_filter_functions)
-
-        if is_dash is not None:
-            filters.append(lambda s: s.is_dash == is_dash)
-
-        return self._filter(filters)
-
-    def _filter(self, filters: List[Callable]) -> "StreamQuery":
-        fmt_streams = self.fmt_streams
-        for filter_lambda in filters:
-            fmt_streams = filter(filter_lambda, fmt_streams)
-        return StreamQuery(list(fmt_streams))
-
-    def order_by(self, attribute_name: str) -> "StreamQuery":
-        """Apply a sort order. Filters out stream the do not have the attribute.
-
-        :param str attribute_name:
-            The name of the attribute to sort by.
-        """
-        has_attribute = [
-            s
-            for s in self.fmt_streams
-            if getattr(s, attribute_name) is not None
-        ]
-        # Check that the attributes have string values.
-        if has_attribute and isinstance(
-            getattr(has_attribute[0], attribute_name), str
-        ):
-            # Try to return a StreamQuery sorted by the integer representations
-            # of the values.
-            try:
-                return StreamQuery(
-                    sorted(
-                        has_attribute,
-                        key=lambda s: int(
-                            "".join(
-                                filter(str.isdigit, getattr(s, attribute_name))
-                            )
-                        ),  # type: ignore  # noqa: E501
-                    )
-                )
-            except ValueError:
-                pass
-
-        return StreamQuery(
-            sorted(has_attribute, key=lambda s: getattr(s, attribute_name))
-        )
-
-    def desc(self) -> "StreamQuery":
-        """Sort streams in descending order.
-
-        :rtype: :class:`StreamQuery <StreamQuery>`
-
-        """
-        return StreamQuery(self.fmt_streams[::-1])
-
-    def asc(self) -> "StreamQuery":
-        """Sort streams in ascending order.
-
-        :rtype: :class:`StreamQuery <StreamQuery>`
-
-        """
-        return self
-
-    def get_by_itag(self, itag: int) -> Optional[Stream]:
-        """Get the corresponding :class:`Stream <Stream>` for a given itag.
-
-        :param int itag:
-            YouTube format identifier code.
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            The :class:`Stream <Stream>` matching the given itag or None if
-            not found.
-
-        """
-        return self.itag_index.get(int(itag))
-
-    def get_by_resolution(self, resolution: str) -> Optional[Stream]:
-        """Get the corresponding :class:`Stream <Stream>` for a given resolution.
-
-        Stream must be a progressive mp4.
-
-        :param str resolution:
-            Video resolution i.e. "720p", "480p", "360p", "240p", "144p"
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            The :class:`Stream <Stream>` matching the given itag or None if
-            not found.
-
-        """
-        return self.filter(
-            progressive=True, subtype="mp4", resolution=resolution
-        ).first()
-
-    def get_lowest_resolution(self) -> Optional[Stream]:
-        """Get lowest resolution stream that is a progressive mp4.
-
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            The :class:`Stream <Stream>` matching the given itag or None if
-            not found.
-
-        """
-        return (
-            self.filter(progressive=True, subtype="mp4")
-            .order_by("resolution")
-            .first()
-        )
-
-    def get_highest_resolution(self) -> Optional[Stream]:
-        """Get highest resolution stream that is a progressive video.
-
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            The :class:`Stream <Stream>` matching the given itag or None if
-            not found.
-
-        """
-        return self.filter(progressive=True).order_by("resolution").last()
-
-    def get_audio_only(self, subtype: str = "mp4") -> Optional[Stream]:
-        """Get highest bitrate audio stream for given codec (defaults to mp4)
-
-        :param str subtype:
-            Audio subtype, defaults to mp4
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            The :class:`Stream <Stream>` matching the given itag or None if
-            not found.
-        """
-        return (
-            self.filter(only_audio=True, subtype=subtype)
-            .order_by("abr")
-            .last()
-        )
-
-    def otf(self, is_otf: bool = False) -> "StreamQuery":
-        """Filter stream by OTF, useful if some streams have 404 URLs
-
-        :param bool is_otf: Set to False to retrieve only non-OTF streams
-        :rtype: :class:`StreamQuery <StreamQuery>`
-        :returns: A StreamQuery object with otf filtered streams
-        """
-        return self._filter([lambda s: s.is_otf == is_otf])
-
-    def first(self) -> Optional[Stream]:
-        """Get the first :class:`Stream <Stream>` in the results.
-
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            the first result of this query or None if the result doesn't
-            contain any streams.
-
-        """
-        try:
-            return self.fmt_streams[0]
-        except IndexError:
-            return None
-
-    def last(self):
-        """Get the last :class:`Stream <Stream>` in the results.
-
-        :rtype: :class:`Stream <Stream>` or None
-        :returns:
-            Return the last result of this query or None if the result
-            doesn't contain any streams.
-
-        """
-        try:
-            return self.fmt_streams[-1]
-        except IndexError:
-            pass
-
-    @deprecated("Get the size of this list directly using len()")
-    def count(self, value: Optional[str] = None) -> int:  # pragma: no cover
-        """Get the count of items in the list.
-
-        :rtype: int
-        """
-        if value:
-            return self.fmt_streams.count(value)
-
-        return len(self)
-
-    @deprecated("This object can be treated as a list, all() is useless")
-    def all(self) -> List[Stream]:  # pragma: no cover
-        """Get all the results represented by this query as a list.
-
-        :rtype: list
-
-        """
-        return self.fmt_streams
-
-    def __getitem__(self, i: Union[slice, int]):
-        return self.fmt_streams[i]
-
-    def __len__(self) -> int:
-        return len(self.fmt_streams)
-
-    def __repr__(self) -> str:
-        return f"{self.fmt_streams}"
-
-
-class CaptionQuery(Mapping):
-    """Interface for querying the available captions."""
-
-    def __init__(self, captions: List[Caption]):
-        """Construct a :class:`Caption <Caption>`.
-
-        param list captions:
-            list of :class:`Caption <Caption>` instances.
-
-        """
-        self.lang_code_index = {c.code: c for c in captions}
-
-    @deprecated(
-        "This object can be treated as a dictionary, i.e. captions['en']"
-    )
-    def get_by_language_code(
-        self, lang_code: str
-    ) -> Optional[Caption]:  # pragma: no cover
-        """Get the :class:`Caption <Caption>` for a given ``lang_code``.
-
-        :param str lang_code:
-            The code that identifies the caption language.
-        :rtype: :class:`Caption <Caption>` or None
-        :returns:
-            The :class:`Caption <Caption>` matching the given ``lang_code`` or
-            None if it does not exist.
-        """
-        return self.lang_code_index.get(lang_code)
-
-    @deprecated("This object can be treated as a dictionary")
-    def all(self) -> List[Caption]:  # pragma: no cover
-        """Get all the results represented by this query as a list.
-
-        :rtype: list
-
-        """
-        return list(self.lang_code_index.values())
-
-    def __getitem__(self, i: str):
-        return self.lang_code_index[i]
-
-    def __len__(self) -> int:
-        return len(self.lang_code_index)
-
-    def __iter__(self):
-        return iter(self.lang_code_index.values())
-
-    def __repr__(self) -> str:
-        return f"{self.lang_code_index}"