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

@@ -1,420 +0,0 @@
-"""
-WSGI Protocol Linter
-====================
-
-This module provides a middleware that performs sanity checks on the
-behavior of the WSGI server and application. It checks that the
-:pep:`3333` WSGI spec is properly implemented. It also warns on some
-common HTTP errors such as non-empty responses for 304 status codes.
-
-.. autoclass:: LintMiddleware
-
-:copyright: 2007 Pallets
-:license: BSD-3-Clause
-"""
-from __future__ import annotations
-
-import typing as t
-from types import TracebackType
-from urllib.parse import urlparse
-from warnings import warn
-
-from ..datastructures import Headers
-from ..http import is_entity_header
-from ..wsgi import FileWrapper
-
-if t.TYPE_CHECKING:
-    from _typeshed.wsgi import StartResponse
-    from _typeshed.wsgi import WSGIApplication
-    from _typeshed.wsgi import WSGIEnvironment
-
-
-class WSGIWarning(Warning):
-    """Warning class for WSGI warnings."""
-
-
-class HTTPWarning(Warning):
-    """Warning class for HTTP warnings."""
-
-
-def check_type(context: str, obj: object, need: t.Type = str) -> None:
-    if type(obj) is not need:
-        warn(
-            f"{context!r} requires {need.__name__!r}, got {type(obj).__name__!r}.",
-            WSGIWarning,
-            stacklevel=3,
-        )
-
-
-class InputStream:
-    def __init__(self, stream: t.IO[bytes]) -> None:
-        self._stream = stream
-
-    def read(self, *args: t.Any) -> bytes:
-        if len(args) == 0:
-            warn(
-                "WSGI does not guarantee an EOF marker on the input stream, thus making"
-                " calls to 'wsgi.input.read()' unsafe. Conforming servers may never"
-                " return from this call.",
-                WSGIWarning,
-                stacklevel=2,
-            )
-        elif len(args) != 1:
-            warn(
-                "Too many parameters passed to 'wsgi.input.read()'.",
-                WSGIWarning,
-                stacklevel=2,
-            )
-        return self._stream.read(*args)
-
-    def readline(self, *args: t.Any) -> bytes:
-        if len(args) == 0:
-            warn(
-                "Calls to 'wsgi.input.readline()' without arguments are unsafe. Use"
-                " 'wsgi.input.read()' instead.",
-                WSGIWarning,
-                stacklevel=2,
-            )
-        elif len(args) == 1:
-            warn(
-                "'wsgi.input.readline()' was called with a size hint. WSGI does not"
-                " support this, although it's available on all major servers.",
-                WSGIWarning,
-                stacklevel=2,
-            )
-        else:
-            raise TypeError("Too many arguments passed to 'wsgi.input.readline()'.")
-        return self._stream.readline(*args)
-
-    def __iter__(self) -> t.Iterator[bytes]:
-        try:
-            return iter(self._stream)
-        except TypeError:
-            warn("'wsgi.input' is not iterable.", WSGIWarning, stacklevel=2)
-            return iter(())
-
-    def close(self) -> None:
-        warn("The application closed the input stream!", WSGIWarning, stacklevel=2)
-        self._stream.close()
-
-
-class ErrorStream:
-    def __init__(self, stream: t.IO[str]) -> None:
-        self._stream = stream
-
-    def write(self, s: str) -> None:
-        check_type("wsgi.error.write()", s, str)
-        self._stream.write(s)
-
-    def flush(self) -> None:
-        self._stream.flush()
-
-    def writelines(self, seq: t.Iterable[str]) -> None:
-        for line in seq:
-            self.write(line)
-
-    def close(self) -> None:
-        warn("The application closed the error stream!", WSGIWarning, stacklevel=2)
-        self._stream.close()
-
-
-class GuardedWrite:
-    def __init__(self, write: t.Callable[[bytes], object], chunks: list[int]) -> None:
-        self._write = write
-        self._chunks = chunks
-
-    def __call__(self, s: bytes) -> None:
-        check_type("write()", s, bytes)
-        self._write(s)
-        self._chunks.append(len(s))
-
-
-class GuardedIterator:
-    def __init__(
-        self,
-        iterator: t.Iterable[bytes],
-        headers_set: tuple[int, Headers],
-        chunks: list[int],
-    ) -> None:
-        self._iterator = iterator
-        self._next = iter(iterator).__next__
-        self.closed = False
-        self.headers_set = headers_set
-        self.chunks = chunks
-
-    def __iter__(self) -> GuardedIterator:
-        return self
-
-    def __next__(self) -> bytes:
-        if self.closed:
-            warn("Iterated over closed 'app_iter'.", WSGIWarning, stacklevel=2)
-
-        rv = self._next()
-
-        if not self.headers_set:
-            warn(
-                "The application returned before it started the response.",
-                WSGIWarning,
-                stacklevel=2,
-            )
-
-        check_type("application iterator items", rv, bytes)
-        self.chunks.append(len(rv))
-        return rv
-
-    def close(self) -> None:
-        self.closed = True
-
-        if hasattr(self._iterator, "close"):
-            self._iterator.close()
-
-        if self.headers_set:
-            status_code, headers = self.headers_set
-            bytes_sent = sum(self.chunks)
-            content_length = headers.get("content-length", type=int)
-
-            if status_code == 304:
-                for key, _value in headers:
-                    key = key.lower()
-                    if key not in ("expires", "content-location") and is_entity_header(
-                        key
-                    ):
-                        warn(
-                            f"Entity header {key!r} found in 304 response.", HTTPWarning
-                        )
-                if bytes_sent:
-                    warn("304 responses must not have a body.", HTTPWarning)
-            elif 100 <= status_code < 200 or status_code == 204:
-                if content_length != 0:
-                    warn(
-                        f"{status_code} responses must have an empty content length.",
-                        HTTPWarning,
-                    )
-                if bytes_sent:
-                    warn(f"{status_code} responses must not have a body.", HTTPWarning)
-            elif content_length is not None and content_length != bytes_sent:
-                warn(
-                    "Content-Length and the number of bytes sent to the"
-                    " client do not match.",
-                    WSGIWarning,
-                )
-
-    def __del__(self) -> None:
-        if not self.closed:
-            try:
-                warn(
-                    "Iterator was garbage collected before it was closed.", WSGIWarning
-                )
-            except Exception:
-                pass
-
-
-class LintMiddleware:
-    """Warns about common errors in the WSGI and HTTP behavior of the
-    server and wrapped application. Some of the issues it checks are:
-
-    -   invalid status codes
-    -   non-bytes sent to the WSGI server
-    -   strings returned from the WSGI application
-    -   non-empty conditional responses
-    -   unquoted etags
-    -   relative URLs in the Location header
-    -   unsafe calls to wsgi.input
-    -   unclosed iterators
-
-    Error information is emitted using the :mod:`warnings` module.
-
-    :param app: The WSGI application to wrap.
-
-    .. code-block:: python
-
-        from werkzeug.middleware.lint import LintMiddleware
-        app = LintMiddleware(app)
-    """
-
-    def __init__(self, app: WSGIApplication) -> None:
-        self.app = app
-
-    def check_environ(self, environ: WSGIEnvironment) -> None:
-        if type(environ) is not dict:
-            warn(
-                "WSGI environment is not a standard Python dict.",
-                WSGIWarning,
-                stacklevel=4,
-            )
-        for key in (
-            "REQUEST_METHOD",
-            "SERVER_NAME",
-            "SERVER_PORT",
-            "wsgi.version",
-            "wsgi.input",
-            "wsgi.errors",
-            "wsgi.multithread",
-            "wsgi.multiprocess",
-            "wsgi.run_once",
-        ):
-            if key not in environ:
-                warn(
-                    f"Required environment key {key!r} not found",
-                    WSGIWarning,
-                    stacklevel=3,
-                )
-        if environ["wsgi.version"] != (1, 0):
-            warn("Environ is not a WSGI 1.0 environ.", WSGIWarning, stacklevel=3)
-
-        script_name = environ.get("SCRIPT_NAME", "")
-        path_info = environ.get("PATH_INFO", "")
-
-        if script_name and script_name[0] != "/":
-            warn(
-                f"'SCRIPT_NAME' does not start with a slash: {script_name!r}",
-                WSGIWarning,
-                stacklevel=3,
-            )
-
-        if path_info and path_info[0] != "/":
-            warn(
-                f"'PATH_INFO' does not start with a slash: {path_info!r}",
-                WSGIWarning,
-                stacklevel=3,
-            )
-
-    def check_start_response(
-        self,
-        status: str,
-        headers: list[tuple[str, str]],
-        exc_info: None | (tuple[type[BaseException], BaseException, TracebackType]),
-    ) -> tuple[int, Headers]:
-        check_type("status", status, str)
-        status_code_str = status.split(None, 1)[0]
-
-        if len(status_code_str) != 3 or not status_code_str.isdecimal():
-            warn("Status code must be three digits.", WSGIWarning, stacklevel=3)
-
-        if len(status) < 4 or status[3] != " ":
-            warn(
-                f"Invalid value for status {status!r}. Valid status strings are three"
-                " digits, a space and a status explanation.",
-                WSGIWarning,
-                stacklevel=3,
-            )
-
-        status_code = int(status_code_str)
-
-        if status_code < 100:
-            warn("Status code < 100 detected.", WSGIWarning, stacklevel=3)
-
-        if type(headers) is not list:
-            warn("Header list is not a list.", WSGIWarning, stacklevel=3)
-
-        for item in headers:
-            if type(item) is not tuple or len(item) != 2:
-                warn("Header items must be 2-item tuples.", WSGIWarning, stacklevel=3)
-            name, value = item
-            if type(name) is not str or type(value) is not str:
-                warn(
-                    "Header keys and values must be strings.", WSGIWarning, stacklevel=3
-                )
-            if name.lower() == "status":
-                warn(
-                    "The status header is not supported due to"
-                    " conflicts with the CGI spec.",
-                    WSGIWarning,
-                    stacklevel=3,
-                )
-
-        if exc_info is not None and not isinstance(exc_info, tuple):
-            warn("Invalid value for exc_info.", WSGIWarning, stacklevel=3)
-
-        headers = Headers(headers)
-        self.check_headers(headers)
-
-        return status_code, headers
-
-    def check_headers(self, headers: Headers) -> None:
-        etag = headers.get("etag")
-
-        if etag is not None:
-            if etag.startswith(("W/", "w/")):
-                if etag.startswith("w/"):
-                    warn(
-                        "Weak etag indicator should be upper case.",
-                        HTTPWarning,
-                        stacklevel=4,
-                    )
-
-                etag = etag[2:]
-
-            if not (etag[:1] == etag[-1:] == '"'):
-                warn("Unquoted etag emitted.", HTTPWarning, stacklevel=4)
-
-        location = headers.get("location")
-
-        if location is not None:
-            if not urlparse(location).netloc:
-                warn(
-                    "Absolute URLs required for location header.",
-                    HTTPWarning,
-                    stacklevel=4,
-                )
-
-    def check_iterator(self, app_iter: t.Iterable[bytes]) -> None:
-        if isinstance(app_iter, str):
-            warn(
-                "The application returned a string. The response will send one"
-                " character at a time to the client, which will kill performance."
-                " Return a list or iterable instead.",
-                WSGIWarning,
-                stacklevel=3,
-            )
-
-    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Iterable[bytes]:
-        if len(args) != 2:
-            warn("A WSGI app takes two arguments.", WSGIWarning, stacklevel=2)
-
-        if kwargs:
-            warn(
-                "A WSGI app does not take keyword arguments.", WSGIWarning, stacklevel=2
-            )
-
-        environ: WSGIEnvironment = args[0]
-        start_response: StartResponse = args[1]
-
-        self.check_environ(environ)
-        environ["wsgi.input"] = InputStream(environ["wsgi.input"])
-        environ["wsgi.errors"] = ErrorStream(environ["wsgi.errors"])
-
-        # Hook our own file wrapper in so that applications will always
-        # iterate to the end and we can check the content length.
-        environ["wsgi.file_wrapper"] = FileWrapper
-
-        headers_set: list[t.Any] = []
-        chunks: list[int] = []
-
-        def checking_start_response(
-            *args: t.Any, **kwargs: t.Any
-        ) -> t.Callable[[bytes], None]:
-            if len(args) not in {2, 3}:
-                warn(
-                    f"Invalid number of arguments: {len(args)}, expected 2 or 3.",
-                    WSGIWarning,
-                    stacklevel=2,
-                )
-
-            if kwargs:
-                warn("'start_response' does not take keyword arguments.", WSGIWarning)
-
-            status: str = args[0]
-            headers: list[tuple[str, str]] = args[1]
-            exc_info: None | (
-                tuple[type[BaseException], BaseException, TracebackType]
-            ) = (args[2] if len(args) == 3 else None)
-
-            headers_set[:] = self.check_start_response(status, headers, exc_info)
-            return GuardedWrite(start_response(status, headers, exc_info), chunks)
-
-        app_iter = self.app(environ, t.cast("StartResponse", checking_start_response))
-        self.check_iterator(app_iter)
-        return GuardedIterator(
-            app_iter, t.cast(t.Tuple[int, Headers], headers_set), chunks
-        )

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

@@ -1,154 +0,0 @@
-"""
-Application Profiler
-====================
-
-This module provides a middleware that profiles each request with the
-:mod:`cProfile` module. This can help identify bottlenecks in your code
-that may be slowing down your application.
-
-.. autoclass:: ProfilerMiddleware
-
-:copyright: 2007 Pallets
-:license: BSD-3-Clause
-"""
-from __future__ import annotations
-
-import os.path
-import sys
-import time
-import typing as t
-from pstats import Stats
-
-try:
-    from cProfile import Profile
-except ImportError:
-    from profile import Profile  # type: ignore
-
-if t.TYPE_CHECKING:
-    from _typeshed.wsgi import StartResponse
-    from _typeshed.wsgi import WSGIApplication
-    from _typeshed.wsgi import WSGIEnvironment
-
-
-class ProfilerMiddleware:
-    """Wrap a WSGI application and profile the execution of each
-    request. Responses are buffered so that timings are more exact.
-
-    If ``stream`` is given, :class:`pstats.Stats` are written to it
-    after each request. If ``profile_dir`` is given, :mod:`cProfile`
-    data files are saved to that directory, one file per request.
-
-    The filename can be customized by passing ``filename_format``. If
-    it is a string, it will be formatted using :meth:`str.format` with
-    the following fields available:
-
-    -   ``{method}`` - The request method; GET, POST, etc.
-    -   ``{path}`` - The request path or 'root' should one not exist.
-    -   ``{elapsed}`` - The elapsed time of the request in milliseconds.
-    -   ``{time}`` - The time of the request.
-
-    If it is a callable, it will be called with the WSGI ``environ`` and
-    be expected to return a filename string. The ``environ`` dictionary
-    will also have the ``"werkzeug.profiler"`` key populated with a
-    dictionary containing the following fields (more may be added in the
-    future):
-    -   ``{elapsed}`` - The elapsed time of the request in milliseconds.
-    -   ``{time}`` - The time of the request.
-
-    :param app: The WSGI application to wrap.
-    :param stream: Write stats to this stream. Disable with ``None``.
-    :param sort_by: A tuple of columns to sort stats by. See
-        :meth:`pstats.Stats.sort_stats`.
-    :param restrictions: A tuple of restrictions to filter stats by. See
-        :meth:`pstats.Stats.print_stats`.
-    :param profile_dir: Save profile data files to this directory.
-    :param filename_format: Format string for profile data file names,
-        or a callable returning a name. See explanation above.
-
-    .. code-block:: python
-
-        from werkzeug.middleware.profiler import ProfilerMiddleware
-        app = ProfilerMiddleware(app)
-
-    .. versionchanged:: 3.0
-        Added the ``"werkzeug.profiler"`` key to the ``filename_format(environ)``
-        parameter with the  ``elapsed`` and ``time`` fields.
-
-    .. versionchanged:: 0.15
-        Stats are written even if ``profile_dir`` is given, and can be
-        disable by passing ``stream=None``.
-
-    .. versionadded:: 0.15
-        Added ``filename_format``.
-
-    .. versionadded:: 0.9
-        Added ``restrictions`` and ``profile_dir``.
-    """
-
-    def __init__(
-        self,
-        app: WSGIApplication,
-        stream: t.IO[str] | None = sys.stdout,
-        sort_by: t.Iterable[str] = ("time", "calls"),
-        restrictions: t.Iterable[str | int | float] = (),
-        profile_dir: str | None = None,
-        filename_format: str = "{method}.{path}.{elapsed:.0f}ms.{time:.0f}.prof",
-    ) -> None:
-        self._app = app
-        self._stream = stream
-        self._sort_by = sort_by
-        self._restrictions = restrictions
-        self._profile_dir = profile_dir
-        self._filename_format = filename_format
-
-    def __call__(
-        self, environ: WSGIEnvironment, start_response: StartResponse
-    ) -> t.Iterable[bytes]:
-        response_body: list[bytes] = []
-
-        def catching_start_response(status, headers, exc_info=None):  # type: ignore
-            start_response(status, headers, exc_info)
-            return response_body.append
-
-        def runapp() -> None:
-            app_iter = self._app(
-                environ, t.cast("StartResponse", catching_start_response)
-            )
-            response_body.extend(app_iter)
-
-            if hasattr(app_iter, "close"):
-                app_iter.close()
-
-        profile = Profile()
-        start = time.time()
-        profile.runcall(runapp)
-        body = b"".join(response_body)
-        elapsed = time.time() - start
-
-        if self._profile_dir is not None:
-            if callable(self._filename_format):
-                environ["werkzeug.profiler"] = {
-                    "elapsed": elapsed * 1000.0,
-                    "time": time.time(),
-                }
-                filename = self._filename_format(environ)
-            else:
-                filename = self._filename_format.format(
-                    method=environ["REQUEST_METHOD"],
-                    path=environ["PATH_INFO"].strip("/").replace("/", ".") or "root",
-                    elapsed=elapsed * 1000.0,
-                    time=time.time(),
-                )
-            filename = os.path.join(self._profile_dir, filename)
-            profile.dump_stats(filename)
-
-        if self._stream is not None:
-            stats = Stats(profile, stream=self._stream)
-            stats.sort_stats(*self._sort_by)
-            print("-" * 80, file=self._stream)
-            path_info = environ.get("PATH_INFO", "")
-            print(f"PATH: {path_info!r}", file=self._stream)
-            stats.print_stats(*self._restrictions)
-            print(f"{'-' * 80}\n", file=self._stream)
-
-        return [body]