@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/werkzeug/sansio/http.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-import re
-import typing as t
-from datetime import datetime
-
-from .._internal import _dt_as_utc
-from ..http import generate_etag
-from ..http import parse_date
-from ..http import parse_etags
-from ..http import parse_if_range_header
-from ..http import unquote_etag
-
-_etag_re = re.compile(r'([Ww]/)?(?:"(.*?)"|(.*?))(?:\s*,\s*|$)')
-
-
-def is_resource_modified(
-    http_range: str | None = None,
-    http_if_range: str | None = None,
-    http_if_modified_since: str | None = None,
-    http_if_none_match: str | None = None,
-    http_if_match: str | None = None,
-    etag: str | None = None,
-    data: bytes | None = None,
-    last_modified: datetime | str | None = None,
-    ignore_if_range: bool = True,
-) -> bool:
-    """Convenience method for conditional requests.
-    :param http_range: Range HTTP header
-    :param http_if_range: If-Range HTTP header
-    :param http_if_modified_since: If-Modified-Since HTTP header
-    :param http_if_none_match: If-None-Match HTTP header
-    :param http_if_match: If-Match HTTP header
-    :param etag: the etag for the response for comparison.
-    :param data: or alternatively the data of the response to automatically
-                 generate an etag using :func:`generate_etag`.
-    :param last_modified: an optional date of the last modification.
-    :param ignore_if_range: If `False`, `If-Range` header will be taken into
-                            account.
-    :return: `True` if the resource was modified, otherwise `False`.
-
-    .. versionadded:: 2.2
-    """
-    if etag is None and data is not None:
-        etag = generate_etag(data)
-    elif data is not None:
-        raise TypeError("both data and etag given")
-
-    unmodified = False
-    if isinstance(last_modified, str):
-        last_modified = parse_date(last_modified)
-
-    # HTTP doesn't use microsecond, remove it to avoid false positive
-    # comparisons. Mark naive datetimes as UTC.
-    if last_modified is not None:
-        last_modified = _dt_as_utc(last_modified.replace(microsecond=0))
-
-    if_range = None
-    if not ignore_if_range and http_range is not None:
-        # https://tools.ietf.org/html/rfc7233#section-3.2
-        # A server MUST ignore an If-Range header field received in a request
-        # that does not contain a Range header field.
-        if_range = parse_if_range_header(http_if_range)
-
-    if if_range is not None and if_range.date is not None:
-        modified_since: datetime | None = if_range.date
-    else:
-        modified_since = parse_date(http_if_modified_since)
-
-    if modified_since and last_modified and last_modified <= modified_since:
-        unmodified = True
-
-    if etag:
-        etag, _ = unquote_etag(etag)
-        etag = t.cast(str, etag)
-
-        if if_range is not None and if_range.etag is not None:
-            unmodified = parse_etags(if_range.etag).contains(etag)
-        else:
-            if_none_match = parse_etags(http_if_none_match)
-            if if_none_match:
-                # https://tools.ietf.org/html/rfc7232#section-3.2
-                # "A recipient MUST use the weak comparison function when comparing
-                # entity-tags for If-None-Match"
-                unmodified = if_none_match.contains_weak(etag)
-
-            # https://tools.ietf.org/html/rfc7232#section-3.1
-            # "Origin server MUST use the strong comparison function when
-            # comparing entity-tags for If-Match"
-            if_match = parse_etags(http_if_match)
-            if if_match:
-                unmodified = not if_match.is_strong(etag)
-
-    return not unmodified
-
-
-_cookie_re = re.compile(
-    r"""
-    ([^=;]*)
-    (?:\s*=\s*
-      (
-        "(?:[^\\"]|\\.)*"
-      |
-        .*?
-      )
-    )?
-    \s*;\s*
-    """,
-    flags=re.ASCII | re.VERBOSE,
-)
-_cookie_unslash_re = re.compile(rb"\\([0-3][0-7]{2}|.)")
-
-
-def _cookie_unslash_replace(m: t.Match[bytes]) -> bytes:
-    v = m.group(1)
-
-    if len(v) == 1:
-        return v
-
-    return int(v, 8).to_bytes(1, "big")
-
-
-def parse_cookie(
-    cookie: str | None = None,
-    cls: type[ds.MultiDict] | None = None,
-) -> ds.MultiDict[str, str]:
-    """Parse a cookie from a string.
-
-    The same key can be provided multiple times, the values are stored
-    in-order. The default :class:`MultiDict` will have the first value
-    first, and all values can be retrieved with
-    :meth:`MultiDict.getlist`.
-
-    :param cookie: The cookie header as a string.
-    :param cls: A dict-like class to store the parsed cookies in.
-        Defaults to :class:`MultiDict`.
-
-    .. versionchanged:: 3.0
-        Passing bytes, and the ``charset`` and ``errors`` parameters, were removed.
-
-    .. versionadded:: 2.2
-    """
-    if cls is None:
-        cls = ds.MultiDict
-
-    if not cookie:
-        return cls()
-
-    cookie = f"{cookie};"
-    out = []
-
-    for ck, cv in _cookie_re.findall(cookie):
-        ck = ck.strip()
-        cv = cv.strip()
-
-        if not ck:
-            continue
-
-        if len(cv) >= 2 and cv[0] == cv[-1] == '"':
-            # Work with bytes here, since a UTF-8 character could be multiple bytes.
-            cv = _cookie_unslash_re.sub(
-                _cookie_unslash_replace, cv[1:-1].encode()
-            ).decode(errors="replace")
-
-        out.append((ck, cv))
-
-    return cls(out)
-
-
-# circular dependencies
-from .. import datastructures as ds

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

@@ -1,321 +0,0 @@
-from __future__ import annotations
-
-import re
-import typing as t
-from dataclasses import dataclass
-from enum import auto
-from enum import Enum
-
-from ..datastructures import Headers
-from ..exceptions import RequestEntityTooLarge
-from ..http import parse_options_header
-
-
-class Event:
-    pass
-
-
-@dataclass(frozen=True)
-class Preamble(Event):
-    data: bytes
-
-
-@dataclass(frozen=True)
-class Field(Event):
-    name: str
-    headers: Headers
-
-
-@dataclass(frozen=True)
-class File(Event):
-    name: str
-    filename: str
-    headers: Headers
-
-
-@dataclass(frozen=True)
-class Data(Event):
-    data: bytes
-    more_data: bool
-
-
-@dataclass(frozen=True)
-class Epilogue(Event):
-    data: bytes
-
-
-class NeedData(Event):
-    pass
-
-
-NEED_DATA = NeedData()
-
-
-class State(Enum):
-    PREAMBLE = auto()
-    PART = auto()
-    DATA = auto()
-    DATA_START = auto()
-    EPILOGUE = auto()
-    COMPLETE = auto()
-
-
-# Multipart line breaks MUST be CRLF (\r\n) by RFC-7578, except that
-# many implementations break this and either use CR or LF alone.
-LINE_BREAK = b"(?:\r\n|\n|\r)"
-BLANK_LINE_RE = re.compile(b"(?:\r\n\r\n|\r\r|\n\n)", re.MULTILINE)
-LINE_BREAK_RE = re.compile(LINE_BREAK, re.MULTILINE)
-# Header values can be continued via a space or tab after the linebreak, as
-# per RFC2231
-HEADER_CONTINUATION_RE = re.compile(b"%s[ \t]" % LINE_BREAK, re.MULTILINE)
-# This must be long enough to contain any line breaks plus any
-# additional boundary markers (--) such that they will be found in a
-# subsequent search
-SEARCH_EXTRA_LENGTH = 8
-
-
-class MultipartDecoder:
-    """Decodes a multipart message as bytes into Python events.
-
-    The part data is returned as available to allow the caller to save
-    the data from memory to disk, if desired.
-    """
-
-    def __init__(
-        self,
-        boundary: bytes,
-        max_form_memory_size: int | None = None,
-        *,
-        max_parts: int | None = None,
-    ) -> None:
-        self.buffer = bytearray()
-        self.complete = False
-        self.max_form_memory_size = max_form_memory_size
-        self.max_parts = max_parts
-        self.state = State.PREAMBLE
-        self.boundary = boundary
-
-        # Note in the below \h i.e. horizontal whitespace is used
-        # as [^\S\n\r] as \h isn't supported in python.
-
-        # The preamble must end with a boundary where the boundary is
-        # prefixed by a line break, RFC2046. Except that many
-        # implementations including Werkzeug's tests omit the line
-        # break prefix. In addition the first boundary could be the
-        # epilogue boundary (for empty form-data) hence the matching
-        # group to understand if it is an epilogue boundary.
-        self.preamble_re = re.compile(
-            rb"%s?--%s(--[^\S\n\r]*%s?|[^\S\n\r]*%s)"
-            % (LINE_BREAK, re.escape(boundary), LINE_BREAK, LINE_BREAK),
-            re.MULTILINE,
-        )
-        # A boundary must include a line break prefix and suffix, and
-        # may include trailing whitespace. In addition the boundary
-        # could be the epilogue boundary hence the matching group to
-        # understand if it is an epilogue boundary.
-        self.boundary_re = re.compile(
-            rb"%s--%s(--[^\S\n\r]*%s?|[^\S\n\r]*%s)"
-            % (LINE_BREAK, re.escape(boundary), LINE_BREAK, LINE_BREAK),
-            re.MULTILINE,
-        )
-        self._search_position = 0
-        self._parts_decoded = 0
-
-    def last_newline(self, data: bytes) -> int:
-        try:
-            last_nl = data.rindex(b"\n")
-        except ValueError:
-            last_nl = len(data)
-        try:
-            last_cr = data.rindex(b"\r")
-        except ValueError:
-            last_cr = len(data)
-
-        return min(last_nl, last_cr)
-
-    def receive_data(self, data: bytes | None) -> None:
-        if data is None:
-            self.complete = True
-        elif (
-            self.max_form_memory_size is not None
-            and len(self.buffer) + len(data) > self.max_form_memory_size
-        ):
-            raise RequestEntityTooLarge()
-        else:
-            self.buffer.extend(data)
-
-    def next_event(self) -> Event:
-        event: Event = NEED_DATA
-
-        if self.state == State.PREAMBLE:
-            match = self.preamble_re.search(self.buffer, self._search_position)
-            if match is not None:
-                if match.group(1).startswith(b"--"):
-                    self.state = State.EPILOGUE
-                else:
-                    self.state = State.PART
-                data = bytes(self.buffer[: match.start()])
-                del self.buffer[: match.end()]
-                event = Preamble(data=data)
-                self._search_position = 0
-            else:
-                # Update the search start position to be equal to the
-                # current buffer length (already searched) minus a
-                # safe buffer for part of the search target.
-                self._search_position = max(
-                    0, len(self.buffer) - len(self.boundary) - SEARCH_EXTRA_LENGTH
-                )
-
-        elif self.state == State.PART:
-            match = BLANK_LINE_RE.search(self.buffer, self._search_position)
-            if match is not None:
-                headers = self._parse_headers(self.buffer[: match.start()])
-                # The final header ends with a single CRLF, however a
-                # blank line indicates the start of the
-                # body. Therefore the end is after the first CRLF.
-                headers_end = (match.start() + match.end()) // 2
-                del self.buffer[:headers_end]
-
-                if "content-disposition" not in headers:
-                    raise ValueError("Missing Content-Disposition header")
-
-                disposition, extra = parse_options_header(
-                    headers["content-disposition"]
-                )
-                name = t.cast(str, extra.get("name"))
-                filename = extra.get("filename")
-                if filename is not None:
-                    event = File(
-                        filename=filename,
-                        headers=headers,
-                        name=name,
-                    )
-                else:
-                    event = Field(
-                        headers=headers,
-                        name=name,
-                    )
-                self.state = State.DATA_START
-                self._search_position = 0
-                self._parts_decoded += 1
-
-                if self.max_parts is not None and self._parts_decoded > self.max_parts:
-                    raise RequestEntityTooLarge()
-            else:
-                # Update the search start position to be equal to the
-                # current buffer length (already searched) minus a
-                # safe buffer for part of the search target.
-                self._search_position = max(0, len(self.buffer) - SEARCH_EXTRA_LENGTH)
-
-        elif self.state == State.DATA_START:
-            data, del_index, more_data = self._parse_data(self.buffer, start=True)
-            del self.buffer[:del_index]
-            event = Data(data=data, more_data=more_data)
-            if more_data:
-                self.state = State.DATA
-
-        elif self.state == State.DATA:
-            data, del_index, more_data = self._parse_data(self.buffer, start=False)
-            del self.buffer[:del_index]
-            if data or not more_data:
-                event = Data(data=data, more_data=more_data)
-
-        elif self.state == State.EPILOGUE and self.complete:
-            event = Epilogue(data=bytes(self.buffer))
-            del self.buffer[:]
-            self.state = State.COMPLETE
-
-        if self.complete and isinstance(event, NeedData):
-            raise ValueError(f"Invalid form-data cannot parse beyond {self.state}")
-
-        return event
-
-    def _parse_headers(self, data: bytes) -> Headers:
-        headers: list[tuple[str, str]] = []
-        # Merge the continued headers into one line
-        data = HEADER_CONTINUATION_RE.sub(b" ", data)
-        # Now there is one header per line
-        for line in data.splitlines():
-            line = line.strip()
-
-            if line != b"":
-                name, _, value = line.decode().partition(":")
-                headers.append((name.strip(), value.strip()))
-        return Headers(headers)
-
-    def _parse_data(self, data: bytes, *, start: bool) -> tuple[bytes, int, bool]:
-        # Body parts must start with CRLF (or CR or LF)
-        if start:
-            match = LINE_BREAK_RE.match(data)
-            data_start = t.cast(t.Match[bytes], match).end()
-        else:
-            data_start = 0
-
-        boundary = b"--" + self.boundary
-
-        if self.buffer.find(boundary) == -1:
-            # No complete boundary in the buffer, but there may be
-            # a partial boundary at the end. As the boundary
-            # starts with either a nl or cr find the earliest and
-            # return up to that as data.
-            data_end = del_index = self.last_newline(data[data_start:]) + data_start
-            # If amount of data after last newline is far from
-            # possible length of partial boundary, we should
-            # assume that there is no partial boundary in the buffer
-            # and return all pending data.
-            if (len(data) - data_end) > len(b"\n" + boundary):
-                data_end = del_index = len(data)
-            more_data = True
-        else:
-            match = self.boundary_re.search(data)
-            if match is not None:
-                if match.group(1).startswith(b"--"):
-                    self.state = State.EPILOGUE
-                else:
-                    self.state = State.PART
-                data_end = match.start()
-                del_index = match.end()
-            else:
-                data_end = del_index = self.last_newline(data[data_start:]) + data_start
-            more_data = match is None
-
-        return bytes(data[data_start:data_end]), del_index, more_data
-
-
-class MultipartEncoder:
-    def __init__(self, boundary: bytes) -> None:
-        self.boundary = boundary
-        self.state = State.PREAMBLE
-
-    def send_event(self, event: Event) -> bytes:
-        if isinstance(event, Preamble) and self.state == State.PREAMBLE:
-            self.state = State.PART
-            return event.data
-        elif isinstance(event, (Field, File)) and self.state in {
-            State.PREAMBLE,
-            State.PART,
-            State.DATA,
-        }:
-            data = b"\r\n--" + self.boundary + b"\r\n"
-            data += b'Content-Disposition: form-data; name="%s"' % event.name.encode()
-            if isinstance(event, File):
-                data += b'; filename="%s"' % event.filename.encode()
-            data += b"\r\n"
-            for name, value in t.cast(Field, event).headers:
-                if name.lower() != "content-disposition":
-                    data += f"{name}: {value}\r\n".encode()
-            self.state = State.DATA_START
-            return data
-        elif isinstance(event, Data) and self.state == State.DATA_START:
-            self.state = State.DATA
-            if len(event.data) > 0:
-                return b"\r\n" + event.data
-            else:
-                return event.data
-        elif isinstance(event, Data) and self.state == State.DATA:
-            return event.data
-        elif isinstance(event, Epilogue):
-            self.state = State.COMPLETE
-            return b"\r\n--" + self.boundary + b"--\r\n" + event.data
-        else:
-            raise ValueError(f"Cannot generate {event} in state: {self.state}")