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

@@ -1,182 +0,0 @@
-"""
-X-Forwarded-For Proxy Fix
-=========================
-
-This module provides a middleware that adjusts the WSGI environ based on
-``X-Forwarded-`` headers that proxies in front of an application may
-set.
-
-When an application is running behind a proxy server, WSGI may see the
-request as coming from that server rather than the real client. Proxies
-set various headers to track where the request actually came from.
-
-This middleware should only be used if the application is actually
-behind such a proxy, and should be configured with the number of proxies
-that are chained in front of it. Not all proxies set all the headers.
-Since incoming headers can be faked, you must set how many proxies are
-setting each header so the middleware knows what to trust.
-
-.. autoclass:: ProxyFix
-
-:copyright: 2007 Pallets
-:license: BSD-3-Clause
-"""
-from __future__ import annotations
-
-import typing as t
-
-from ..http import parse_list_header
-
-if t.TYPE_CHECKING:
-    from _typeshed.wsgi import StartResponse
-    from _typeshed.wsgi import WSGIApplication
-    from _typeshed.wsgi import WSGIEnvironment
-
-
-class ProxyFix:
-    """Adjust the WSGI environ based on ``X-Forwarded-`` that proxies in
-    front of the application may set.
-
-    -   ``X-Forwarded-For`` sets ``REMOTE_ADDR``.
-    -   ``X-Forwarded-Proto`` sets ``wsgi.url_scheme``.
-    -   ``X-Forwarded-Host`` sets ``HTTP_HOST``, ``SERVER_NAME``, and
-        ``SERVER_PORT``.
-    -   ``X-Forwarded-Port`` sets ``HTTP_HOST`` and ``SERVER_PORT``.
-    -   ``X-Forwarded-Prefix`` sets ``SCRIPT_NAME``.
-
-    You must tell the middleware how many proxies set each header so it
-    knows what values to trust. It is a security issue to trust values
-    that came from the client rather than a proxy.
-
-    The original values of the headers are stored in the WSGI
-    environ as ``werkzeug.proxy_fix.orig``, a dict.
-
-    :param app: The WSGI application to wrap.
-    :param x_for: Number of values to trust for ``X-Forwarded-For``.
-    :param x_proto: Number of values to trust for ``X-Forwarded-Proto``.
-    :param x_host: Number of values to trust for ``X-Forwarded-Host``.
-    :param x_port: Number of values to trust for ``X-Forwarded-Port``.
-    :param x_prefix: Number of values to trust for
-        ``X-Forwarded-Prefix``.
-
-    .. code-block:: python
-
-        from werkzeug.middleware.proxy_fix import ProxyFix
-        # App is behind one proxy that sets the -For and -Host headers.
-        app = ProxyFix(app, x_for=1, x_host=1)
-
-    .. versionchanged:: 1.0
-        The ``num_proxies`` argument and attribute; the ``get_remote_addr`` method; and
-        the environ keys ``orig_remote_addr``, ``orig_wsgi_url_scheme``, and
-        ``orig_http_host`` were removed.
-
-    .. versionchanged:: 0.15
-        All headers support multiple values. Each header is configured with a separate
-        number of trusted proxies.
-
-    .. versionchanged:: 0.15
-        Original WSGI environ values are stored in the ``werkzeug.proxy_fix.orig`` dict.
-
-    .. versionchanged:: 0.15
-        Support ``X-Forwarded-Port`` and ``X-Forwarded-Prefix``.
-
-    .. versionchanged:: 0.15
-        ``X-Forwarded-Host`` and ``X-Forwarded-Port`` modify
-        ``SERVER_NAME`` and ``SERVER_PORT``.
-    """
-
-    def __init__(
-        self,
-        app: WSGIApplication,
-        x_for: int = 1,
-        x_proto: int = 1,
-        x_host: int = 0,
-        x_port: int = 0,
-        x_prefix: int = 0,
-    ) -> None:
-        self.app = app
-        self.x_for = x_for
-        self.x_proto = x_proto
-        self.x_host = x_host
-        self.x_port = x_port
-        self.x_prefix = x_prefix
-
-    def _get_real_value(self, trusted: int, value: str | None) -> str | None:
-        """Get the real value from a list header based on the configured
-        number of trusted proxies.
-
-        :param trusted: Number of values to trust in the header.
-        :param value: Comma separated list header value to parse.
-        :return: The real value, or ``None`` if there are fewer values
-            than the number of trusted proxies.
-
-        .. versionchanged:: 1.0
-            Renamed from ``_get_trusted_comma``.
-
-        .. versionadded:: 0.15
-        """
-        if not (trusted and value):
-            return None
-        values = parse_list_header(value)
-        if len(values) >= trusted:
-            return values[-trusted]
-        return None
-
-    def __call__(
-        self, environ: WSGIEnvironment, start_response: StartResponse
-    ) -> t.Iterable[bytes]:
-        """Modify the WSGI environ based on the various ``Forwarded``
-        headers before calling the wrapped application. Store the
-        original environ values in ``werkzeug.proxy_fix.orig_{key}``.
-        """
-        environ_get = environ.get
-        orig_remote_addr = environ_get("REMOTE_ADDR")
-        orig_wsgi_url_scheme = environ_get("wsgi.url_scheme")
-        orig_http_host = environ_get("HTTP_HOST")
-        environ.update(
-            {
-                "werkzeug.proxy_fix.orig": {
-                    "REMOTE_ADDR": orig_remote_addr,
-                    "wsgi.url_scheme": orig_wsgi_url_scheme,
-                    "HTTP_HOST": orig_http_host,
-                    "SERVER_NAME": environ_get("SERVER_NAME"),
-                    "SERVER_PORT": environ_get("SERVER_PORT"),
-                    "SCRIPT_NAME": environ_get("SCRIPT_NAME"),
-                }
-            }
-        )
-
-        x_for = self._get_real_value(self.x_for, environ_get("HTTP_X_FORWARDED_FOR"))
-        if x_for:
-            environ["REMOTE_ADDR"] = x_for
-
-        x_proto = self._get_real_value(
-            self.x_proto, environ_get("HTTP_X_FORWARDED_PROTO")
-        )
-        if x_proto:
-            environ["wsgi.url_scheme"] = x_proto
-
-        x_host = self._get_real_value(self.x_host, environ_get("HTTP_X_FORWARDED_HOST"))
-        if x_host:
-            environ["HTTP_HOST"] = environ["SERVER_NAME"] = x_host
-            # "]" to check for IPv6 address without port
-            if ":" in x_host and not x_host.endswith("]"):
-                environ["SERVER_NAME"], environ["SERVER_PORT"] = x_host.rsplit(":", 1)
-
-        x_port = self._get_real_value(self.x_port, environ_get("HTTP_X_FORWARDED_PORT"))
-        if x_port:
-            host = environ.get("HTTP_HOST")
-            if host:
-                # "]" to check for IPv6 address without port
-                if ":" in host and not host.endswith("]"):
-                    host = host.rsplit(":", 1)[0]
-                environ["HTTP_HOST"] = f"{host}:{x_port}"
-            environ["SERVER_PORT"] = x_port
-
-        x_prefix = self._get_real_value(
-            self.x_prefix, environ_get("HTTP_X_FORWARDED_PREFIX")
-        )
-        if x_prefix:
-            environ["SCRIPT_NAME"] = x_prefix
-
-        return self.app(environ, start_response)

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

@@ -1,282 +0,0 @@
-"""
-Serve Shared Static Files
-=========================
-
-.. autoclass:: SharedDataMiddleware
-    :members: is_allowed
-
-:copyright: 2007 Pallets
-:license: BSD-3-Clause
-"""
-from __future__ import annotations
-
-import importlib.util
-import mimetypes
-import os
-import posixpath
-import typing as t
-from datetime import datetime
-from datetime import timezone
-from io import BytesIO
-from time import time
-from zlib import adler32
-
-from ..http import http_date
-from ..http import is_resource_modified
-from ..security import safe_join
-from ..utils import get_content_type
-from ..wsgi import get_path_info
-from ..wsgi import wrap_file
-
-_TOpener = t.Callable[[], t.Tuple[t.IO[bytes], datetime, int]]
-_TLoader = t.Callable[[t.Optional[str]], t.Tuple[t.Optional[str], t.Optional[_TOpener]]]
-
-if t.TYPE_CHECKING:
-    from _typeshed.wsgi import StartResponse
-    from _typeshed.wsgi import WSGIApplication
-    from _typeshed.wsgi import WSGIEnvironment
-
-
-class SharedDataMiddleware:
-
-    """A WSGI middleware which provides static content for development
-    environments or simple server setups. Its usage is quite simple::
-
-        import os
-        from werkzeug.middleware.shared_data import SharedDataMiddleware
-
-        app = SharedDataMiddleware(app, {
-            '/shared': os.path.join(os.path.dirname(__file__), 'shared')
-        })
-
-    The contents of the folder ``./shared`` will now be available on
-    ``http://example.com/shared/``.  This is pretty useful during development
-    because a standalone media server is not required. Files can also be
-    mounted on the root folder and still continue to use the application because
-    the shared data middleware forwards all unhandled requests to the
-    application, even if the requests are below one of the shared folders.
-
-    If `pkg_resources` is available you can also tell the middleware to serve
-    files from package data::
-
-        app = SharedDataMiddleware(app, {
-            '/static': ('myapplication', 'static')
-        })
-
-    This will then serve the ``static`` folder in the `myapplication`
-    Python package.
-
-    The optional `disallow` parameter can be a list of :func:`~fnmatch.fnmatch`
-    rules for files that are not accessible from the web.  If `cache` is set to
-    `False` no caching headers are sent.
-
-    Currently the middleware does not support non-ASCII filenames. If the
-    encoding on the file system happens to match the encoding of the URI it may
-    work but this could also be by accident. We strongly suggest using ASCII
-    only file names for static files.
-
-    The middleware will guess the mimetype using the Python `mimetype`
-    module.  If it's unable to figure out the charset it will fall back
-    to `fallback_mimetype`.
-
-    :param app: the application to wrap.  If you don't want to wrap an
-                application you can pass it :exc:`NotFound`.
-    :param exports: a list or dict of exported files and folders.
-    :param disallow: a list of :func:`~fnmatch.fnmatch` rules.
-    :param cache: enable or disable caching headers.
-    :param cache_timeout: the cache timeout in seconds for the headers.
-    :param fallback_mimetype: The fallback mimetype for unknown files.
-
-    .. versionchanged:: 1.0
-        The default ``fallback_mimetype`` is
-        ``application/octet-stream``. If a filename looks like a text
-        mimetype, the ``utf-8`` charset is added to it.
-
-    .. versionadded:: 0.6
-        Added ``fallback_mimetype``.
-
-    .. versionchanged:: 0.5
-        Added ``cache_timeout``.
-    """
-
-    def __init__(
-        self,
-        app: WSGIApplication,
-        exports: (
-            dict[str, str | tuple[str, str]]
-            | t.Iterable[tuple[str, str | tuple[str, str]]]
-        ),
-        disallow: None = None,
-        cache: bool = True,
-        cache_timeout: int = 60 * 60 * 12,
-        fallback_mimetype: str = "application/octet-stream",
-    ) -> None:
-        self.app = app
-        self.exports: list[tuple[str, _TLoader]] = []
-        self.cache = cache
-        self.cache_timeout = cache_timeout
-
-        if isinstance(exports, dict):
-            exports = exports.items()
-
-        for key, value in exports:
-            if isinstance(value, tuple):
-                loader = self.get_package_loader(*value)
-            elif isinstance(value, str):
-                if os.path.isfile(value):
-                    loader = self.get_file_loader(value)
-                else:
-                    loader = self.get_directory_loader(value)
-            else:
-                raise TypeError(f"unknown def {value!r}")
-
-            self.exports.append((key, loader))
-
-        if disallow is not None:
-            from fnmatch import fnmatch
-
-            self.is_allowed = lambda x: not fnmatch(x, disallow)
-
-        self.fallback_mimetype = fallback_mimetype
-
-    def is_allowed(self, filename: str) -> bool:
-        """Subclasses can override this method to disallow the access to
-        certain files.  However by providing `disallow` in the constructor
-        this method is overwritten.
-        """
-        return True
-
-    def _opener(self, filename: str) -> _TOpener:
-        return lambda: (
-            open(filename, "rb"),
-            datetime.fromtimestamp(os.path.getmtime(filename), tz=timezone.utc),
-            int(os.path.getsize(filename)),
-        )
-
-    def get_file_loader(self, filename: str) -> _TLoader:
-        return lambda x: (os.path.basename(filename), self._opener(filename))
-
-    def get_package_loader(self, package: str, package_path: str) -> _TLoader:
-        load_time = datetime.now(timezone.utc)
-        spec = importlib.util.find_spec(package)
-        reader = spec.loader.get_resource_reader(package)  # type: ignore[union-attr]
-
-        def loader(
-            path: str | None,
-        ) -> tuple[str | None, _TOpener | None]:
-            if path is None:
-                return None, None
-
-            path = safe_join(package_path, path)
-
-            if path is None:
-                return None, None
-
-            basename = posixpath.basename(path)
-
-            try:
-                resource = reader.open_resource(path)
-            except OSError:
-                return None, None
-
-            if isinstance(resource, BytesIO):
-                return (
-                    basename,
-                    lambda: (resource, load_time, len(resource.getvalue())),
-                )
-
-            return (
-                basename,
-                lambda: (
-                    resource,
-                    datetime.fromtimestamp(
-                        os.path.getmtime(resource.name), tz=timezone.utc
-                    ),
-                    os.path.getsize(resource.name),
-                ),
-            )
-
-        return loader
-
-    def get_directory_loader(self, directory: str) -> _TLoader:
-        def loader(
-            path: str | None,
-        ) -> tuple[str | None, _TOpener | None]:
-            if path is not None:
-                path = safe_join(directory, path)
-
-                if path is None:
-                    return None, None
-            else:
-                path = directory
-
-            if os.path.isfile(path):
-                return os.path.basename(path), self._opener(path)
-
-            return None, None
-
-        return loader
-
-    def generate_etag(self, mtime: datetime, file_size: int, real_filename: str) -> str:
-        real_filename = os.fsencode(real_filename)
-        timestamp = mtime.timestamp()
-        checksum = adler32(real_filename) & 0xFFFFFFFF
-        return f"wzsdm-{timestamp}-{file_size}-{checksum}"
-
-    def __call__(
-        self, environ: WSGIEnvironment, start_response: StartResponse
-    ) -> t.Iterable[bytes]:
-        path = get_path_info(environ)
-        file_loader = None
-
-        for search_path, loader in self.exports:
-            if search_path == path:
-                real_filename, file_loader = loader(None)
-
-                if file_loader is not None:
-                    break
-
-            if not search_path.endswith("/"):
-                search_path += "/"
-
-            if path.startswith(search_path):
-                real_filename, file_loader = loader(path[len(search_path) :])
-
-                if file_loader is not None:
-                    break
-
-        if file_loader is None or not self.is_allowed(real_filename):  # type: ignore
-            return self.app(environ, start_response)
-
-        guessed_type = mimetypes.guess_type(real_filename)  # type: ignore
-        mime_type = get_content_type(guessed_type[0] or self.fallback_mimetype, "utf-8")
-        f, mtime, file_size = file_loader()
-
-        headers = [("Date", http_date())]
-
-        if self.cache:
-            timeout = self.cache_timeout
-            etag = self.generate_etag(mtime, file_size, real_filename)  # type: ignore
-            headers += [
-                ("Etag", f'"{etag}"'),
-                ("Cache-Control", f"max-age={timeout}, public"),
-            ]
-
-            if not is_resource_modified(environ, etag, last_modified=mtime):
-                f.close()
-                start_response("304 Not Modified", headers)
-                return []
-
-            headers.append(("Expires", http_date(time() + timeout)))
-        else:
-            headers.append(("Cache-Control", "public"))
-
-        headers.extend(
-            (
-                ("Content-Type", mime_type),
-                ("Content-Length", str(file_size)),
-                ("Last-Modified", http_date(mtime)),
-            )
-        )
-        start_response("200 OK", headers)
-        return wrap_file(environ, f)

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

@@ -1,133 +0,0 @@
-"""When it comes to combining multiple controller or view functions
-(however you want to call them) you need a dispatcher. A simple way
-would be applying regular expression tests on the ``PATH_INFO`` and
-calling registered callback functions that return the value then.
-
-This module implements a much more powerful system than simple regular
-expression matching because it can also convert values in the URLs and
-build URLs.
-
-Here a simple example that creates a URL map for an application with
-two subdomains (www and kb) and some URL rules:
-
-.. code-block:: python
-
-    m = Map([
-        # Static URLs
-        Rule('/', endpoint='static/index'),
-        Rule('/about', endpoint='static/about'),
-        Rule('/help', endpoint='static/help'),
-        # Knowledge Base
-        Subdomain('kb', [
-            Rule('/', endpoint='kb/index'),
-            Rule('/browse/', endpoint='kb/browse'),
-            Rule('/browse/<int:id>/', endpoint='kb/browse'),
-            Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')
-        ])
-    ], default_subdomain='www')
-
-If the application doesn't use subdomains it's perfectly fine to not set
-the default subdomain and not use the `Subdomain` rule factory. The
-endpoint in the rules can be anything, for example import paths or
-unique identifiers. The WSGI application can use those endpoints to get the
-handler for that URL.  It doesn't have to be a string at all but it's
-recommended.
-
-Now it's possible to create a URL adapter for one of the subdomains and
-build URLs:
-
-.. code-block:: python
-
-    c = m.bind('example.com')
-
-    c.build("kb/browse", dict(id=42))
-    'http://kb.example.com/browse/42/'
-
-    c.build("kb/browse", dict())
-    'http://kb.example.com/browse/'
-
-    c.build("kb/browse", dict(id=42, page=3))
-    'http://kb.example.com/browse/42/3'
-
-    c.build("static/about")
-    '/about'
-
-    c.build("static/index", force_external=True)
-    'http://www.example.com/'
-
-    c = m.bind('example.com', subdomain='kb')
-
-    c.build("static/about")
-    'http://www.example.com/about'
-
-The first argument to bind is the server name *without* the subdomain.
-Per default it will assume that the script is mounted on the root, but
-often that's not the case so you can provide the real mount point as
-second argument:
-
-.. code-block:: python
-
-    c = m.bind('example.com', '/applications/example')
-
-The third argument can be the subdomain, if not given the default
-subdomain is used.  For more details about binding have a look at the
-documentation of the `MapAdapter`.
-
-And here is how you can match URLs:
-
-.. code-block:: python
-
-    c = m.bind('example.com')
-
-    c.match("/")
-    ('static/index', {})
-
-    c.match("/about")
-    ('static/about', {})
-
-    c = m.bind('example.com', '/', 'kb')
-
-    c.match("/")
-    ('kb/index', {})
-
-    c.match("/browse/42/23")
-    ('kb/browse', {'id': 42, 'page': 23})
-
-If matching fails you get a ``NotFound`` exception, if the rule thinks
-it's a good idea to redirect (for example because the URL was defined
-to have a slash at the end but the request was missing that slash) it
-will raise a ``RequestRedirect`` exception. Both are subclasses of
-``HTTPException`` so you can use those errors as responses in the
-application.
-
-If matching succeeded but the URL rule was incompatible to the given
-method (for example there were only rules for ``GET`` and ``HEAD`` but
-routing tried to match a ``POST`` request) a ``MethodNotAllowed``
-exception is raised.
-"""
-from .converters import AnyConverter as AnyConverter
-from .converters import BaseConverter as BaseConverter
-from .converters import FloatConverter as FloatConverter
-from .converters import IntegerConverter as IntegerConverter
-from .converters import PathConverter as PathConverter
-from .converters import UnicodeConverter as UnicodeConverter
-from .converters import UUIDConverter as UUIDConverter
-from .converters import ValidationError as ValidationError
-from .exceptions import BuildError as BuildError
-from .exceptions import NoMatch as NoMatch
-from .exceptions import RequestAliasRedirect as RequestAliasRedirect
-from .exceptions import RequestPath as RequestPath
-from .exceptions import RequestRedirect as RequestRedirect
-from .exceptions import RoutingException as RoutingException
-from .exceptions import WebsocketMismatch as WebsocketMismatch
-from .map import Map as Map
-from .map import MapAdapter as MapAdapter
-from .matcher import StateMachineMatcher as StateMachineMatcher
-from .rules import EndpointPrefix as EndpointPrefix
-from .rules import parse_converter_args as parse_converter_args
-from .rules import Rule as Rule
-from .rules import RuleFactory as RuleFactory
-from .rules import RuleTemplate as RuleTemplate
-from .rules import RuleTemplateFactory as RuleTemplateFactory
-from .rules import Subdomain as Subdomain
-from .rules import Submount as Submount