npm - @tushar-br/desktop - Versions diffs - 1.0.283 → 1.0.284 - Mend

@tushar-br/desktop 1.0.283 → 1.0.284

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of @tushar-br/desktop might be problematic. Click here for more details.

Files changed (3797) hide show

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

@@ -1,181 +0,0 @@
-"""A small application that can be used to test a WSGI server and check
-it for WSGI compliance.
-"""
-from __future__ import annotations
-import os
-import sys
-import typing as t
-from textwrap import wrap
-from markupsafe import escape
-from . import __version__ as _werkzeug_version
-from .wrappers.request import Request
-from .wrappers.response import Response
-TEMPLATE = """\
-<!doctype html>
-<html lang=en>
-<title>WSGI Information</title>
-<style type="text/css">
-  @import url(https://fonts.googleapis.com/css?family=Ubuntu);
-  body       { font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
-               'Verdana', sans-serif; background-color: white; color: #000;
-               font-size: 15px; text-align: center; }
-  div.box    { text-align: left; width: 45em; margin: auto; padding: 50px 0;
-               background-color: white; }
-  h1, h2     { font-family: 'Ubuntu', 'Lucida Grande', 'Lucida Sans Unicode',
-               'Geneva', 'Verdana', sans-serif; font-weight: normal; }
-  h1         { margin: 0 0 30px 0; }
-  h2         { font-size: 1.4em; margin: 1em 0 0.5em 0; }
-  table      { width: 100%%; border-collapse: collapse; border: 1px solid #AFC5C9 }
-  table th   { background-color: #AFC1C4; color: white; font-size: 0.72em;
-               font-weight: normal; width: 18em; vertical-align: top;
-               padding: 0.5em 0 0.1em 0.5em; }
-  table td   { border: 1px solid #AFC5C9; padding: 0.1em 0 0.1em 0.5em; }
-  code       { font-family: 'Consolas', 'Monaco', 'Bitstream Vera Sans Mono',
-               monospace; font-size: 0.7em; }
-  ul li      { line-height: 1.5em; }
-  ul.path    { font-size: 0.7em; margin: 0 -30px; padding: 8px 30px;
-               list-style: none; background: #E8EFF0; }
-  ul.path li { line-height: 1.6em; }
-  li.virtual { color: #999; text-decoration: underline; }
-  li.exp     { background: white; }
-</style>
-<div class="box">
-  <h1>WSGI Information</h1>
-  <p>
-    This page displays all available information about the WSGI server and
-    the underlying Python interpreter.
-  <h2 id="python-interpreter">Python Interpreter</h2>
-  <table>
-    <tr>
-      <th>Python Version
-      <td>%(python_version)s
-    <tr>
-      <th>Platform
-      <td>%(platform)s [%(os)s]
-    <tr>
-      <th>API Version
-      <td>%(api_version)s
-    <tr>
-      <th>Byteorder
-      <td>%(byteorder)s
-    <tr>
-      <th>Werkzeug Version
-      <td>%(werkzeug_version)s
-  </table>
-  <h2 id="wsgi-environment">WSGI Environment</h2>
-  <table>%(wsgi_env)s</table>
-  <h2 id="installed-eggs">Installed Eggs</h2>
-  <p>
-    The following python packages were installed on the system as
-    Python eggs:
-  <ul>%(python_eggs)s</ul>
-  <h2 id="sys-path">System Path</h2>
-  <p>
-    The following paths are the current contents of the load path.  The
-    following entries are looked up for Python packages.  Note that not
-    all items in this path are folders.  Gray and underlined items are
-    entries pointing to invalid resources or used by custom import hooks
-    such as the zip importer.
-  <p>
-    Items with a bright background were expanded for display from a relative
-    path.  If you encounter such paths in the output you might want to check
-    your setup as relative paths are usually problematic in multithreaded
-    environments.
-  <ul class="path">%(sys_path)s</ul>
-</div>
-"""
-def iter_sys_path() -> t.Iterator[tuple[str, bool, bool]]:
-    if os.name == "posix":
-        def strip(x: str) -> str:
-            prefix = os.path.expanduser("~")
-            if x.startswith(prefix):
-                x = f"~{x[len(prefix) :]}"
-            return x
-    else:
-        def strip(x: str) -> str:
-            return x
-    cwd = os.path.abspath(os.getcwd())
-    for item in sys.path:
-        path = os.path.join(cwd, item or os.path.curdir)
-        yield strip(os.path.normpath(path)), not os.path.isdir(path), path != item
-@Request.application
-def test_app(req: Request) -> Response:
-    """Simple test application that dumps the environment.  You can use
-    it to check if Werkzeug is working properly:
-    .. sourcecode:: pycon
-        >>> from werkzeug.serving import run_simple
-        >>> from werkzeug.testapp import test_app
-        >>> run_simple('localhost', 3000, test_app)
-         * Running on http://localhost:3000/
-    The application displays important information from the WSGI environment,
-    the Python interpreter and the installed libraries.
-    """
-    try:
-        import pkg_resources
-    except ImportError:
-        eggs: t.Iterable[t.Any] = ()
-    else:
-        eggs = sorted(
-            pkg_resources.working_set,
-            key=lambda x: x.project_name.lower(),
-        )
-    python_eggs = []
-    for egg in eggs:
-        try:
-            version = egg.version
-        except (ValueError, AttributeError):
-            version = "unknown"
-        python_eggs.append(
-            f"<li>{escape(egg.project_name)} <small>[{escape(version)}]</small>"
-        )
-    wsgi_env = []
-    sorted_environ = sorted(req.environ.items(), key=lambda x: repr(x[0]).lower())
-    for key, value in sorted_environ:
-        value = "".join(wrap(str(escape(repr(value)))))
-        wsgi_env.append(f"<tr><th>{escape(key)}<td><code>{value}</code>")
-    sys_path = []
-    for item, virtual, expanded in iter_sys_path():
-        class_ = []
-        if virtual:
-            class_.append("virtual")
-        if expanded:
-            class_.append("exp")
-        class_ = f' class="{" ".join(class_)}"' if class_ else ""
-        sys_path.append(f"<li{class_}>{escape(item)}")
-    context = {
-        "python_version": "<br>".join(escape(sys.version).splitlines()),
-        "platform": escape(sys.platform),
-        "os": escape(os.name),
-        "api_version": sys.api_version,
-        "byteorder": sys.byteorder,
-        "werkzeug_version": _werkzeug_version,
-        "python_eggs": "\n".join(python_eggs),
-        "wsgi_env": "\n".join(wsgi_env),
-        "sys_path": "\n".join(sys_path),
-    }
-    return Response(TEMPLATE % context, mimetype="text/html")
-if __name__ == "__main__":
-    from .serving import run_simple
-    run_simple("localhost", 5000, test_app, use_reloader=True)

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

@@ -1,216 +0,0 @@
-from __future__ import annotations
-import codecs
-import re
-import typing as t
-from urllib.parse import quote
-from urllib.parse import unquote
-from urllib.parse import urlencode
-from urllib.parse import urlsplit
-from urllib.parse import urlunsplit
-from .datastructures import iter_multi_items
-def _codec_error_url_quote(e: UnicodeError) -> tuple[str, int]:
-    """Used in :func:`uri_to_iri` after unquoting to re-quote any
-    invalid bytes.
-    """
-    # the docs state that UnicodeError does have these attributes,
-    # but mypy isn't picking them up
-    out = quote(e.object[e.start : e.end], safe="")  # type: ignore
-    return out, e.end  # type: ignore
-codecs.register_error("werkzeug.url_quote", _codec_error_url_quote)
-def _make_unquote_part(name: str, chars: str) -> t.Callable[[str], str]:
-    """Create a function that unquotes all percent encoded characters except those
-    given. This allows working with unquoted characters if possible while not changing
-    the meaning of a given part of a URL.
-    """
-    choices = "|".join(f"{ord(c):02X}" for c in sorted(chars))
-    pattern = re.compile(f"((?:%(?:{choices}))+)", re.I)
-    def _unquote_partial(value: str) -> str:
-        parts = iter(pattern.split(value))
-        out = []
-        for part in parts:
-            out.append(unquote(part, "utf-8", "werkzeug.url_quote"))
-            out.append(next(parts, ""))
-        return "".join(out)
-    _unquote_partial.__name__ = f"_unquote_{name}"
-    return _unquote_partial
-# characters that should remain quoted in URL parts
-# based on https://url.spec.whatwg.org/#percent-encoded-bytes
-# always keep all controls, space, and % quoted
-_always_unsafe = bytes((*range(0x21), 0x25, 0x7F)).decode()
-_unquote_fragment = _make_unquote_part("fragment", _always_unsafe)
-_unquote_query = _make_unquote_part("query", _always_unsafe + "&=+#")
-_unquote_path = _make_unquote_part("path", _always_unsafe + "/?#")
-_unquote_user = _make_unquote_part("user", _always_unsafe + ":@/?#")
-def uri_to_iri(uri: str) -> str:
-    """Convert a URI to an IRI. All valid UTF-8 characters are unquoted,
-    leaving all reserved and invalid characters quoted. If the URL has
-    a domain, it is decoded from Punycode.
-    >>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF")
-    'http://\\u2603.net/p\\xe5th?q=\\xe8ry%DF'
-    :param uri: The URI to convert.
-    .. versionchanged:: 3.0
-        Passing a tuple or bytes, and the ``charset`` and ``errors`` parameters,
-        are removed.
-    .. versionchanged:: 2.3
-        Which characters remain quoted is specific to each part of the URL.
-    .. versionchanged:: 0.15
-        All reserved and invalid characters remain quoted. Previously,
-        only some reserved characters were preserved, and invalid bytes
-        were replaced instead of left quoted.
-    .. versionadded:: 0.6
-    """
-    parts = urlsplit(uri)
-    path = _unquote_path(parts.path)
-    query = _unquote_query(parts.query)
-    fragment = _unquote_fragment(parts.fragment)
-    if parts.hostname:
-        netloc = _decode_idna(parts.hostname)
-    else:
-        netloc = ""
-    if ":" in netloc:
-        netloc = f"[{netloc}]"
-    if parts.port:
-        netloc = f"{netloc}:{parts.port}"
-    if parts.username:
-        auth = _unquote_user(parts.username)
-        if parts.password:
-            password = _unquote_user(parts.password)
-            auth = f"{auth}:{password}"
-        netloc = f"{auth}@{netloc}"
-    return urlunsplit((parts.scheme, netloc, path, query, fragment))
-def iri_to_uri(iri: str) -> str:
-    """Convert an IRI to a URI. All non-ASCII and unsafe characters are
-    quoted. If the URL has a domain, it is encoded to Punycode.
-    >>> iri_to_uri('http://\\u2603.net/p\\xe5th?q=\\xe8ry%DF')
-    'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF'
-    :param iri: The IRI to convert.
-    .. versionchanged:: 3.0
-        Passing a tuple or bytes, the ``charset`` and ``errors`` parameters,
-        and the ``safe_conversion`` parameter, are removed.
-    .. versionchanged:: 2.3
-        Which characters remain unquoted is specific to each part of the URL.
-    .. versionchanged:: 0.15
-        All reserved characters remain unquoted. Previously, only some reserved
-        characters were left unquoted.
-    .. versionchanged:: 0.9.6
-       The ``safe_conversion`` parameter was added.
-    .. versionadded:: 0.6
-    """
-    parts = urlsplit(iri)
-    # safe = https://url.spec.whatwg.org/#url-path-segment-string
-    # as well as percent for things that are already quoted
-    path = quote(parts.path, safe="%!$&'()*+,/:;=@")
-    query = quote(parts.query, safe="%!$&'()*+,/:;=?@")
-    fragment = quote(parts.fragment, safe="%!#$&'()*+,/:;=?@")
-    if parts.hostname:
-        netloc = parts.hostname.encode("idna").decode("ascii")
-    else:
-        netloc = ""
-    if ":" in netloc:
-        netloc = f"[{netloc}]"
-    if parts.port:
-        netloc = f"{netloc}:{parts.port}"
-    if parts.username:
-        auth = quote(parts.username, safe="%!$&'()*+,;=")
-        if parts.password:
-            password = quote(parts.password, safe="%!$&'()*+,;=")
-            auth = f"{auth}:{password}"
-        netloc = f"{auth}@{netloc}"
-    return urlunsplit((parts.scheme, netloc, path, query, fragment))
-def _invalid_iri_to_uri(iri: str) -> str:
-    """The URL scheme ``itms-services://`` must contain the ``//`` even though it does
-    not have a host component. There may be other invalid schemes as well. Currently,
-    responses will always call ``iri_to_uri`` on the redirect ``Location`` header, which
-    removes the ``//``. For now, if the IRI only contains ASCII and does not contain
-    spaces, pass it on as-is. In Werkzeug 3.0, this should become a
-    ``response.process_location`` flag.
-    :meta private:
-    """
-    try:
-        iri.encode("ascii")
-    except UnicodeError:
-        pass
-    else:
-        if len(iri.split(None, 1)) == 1:
-            return iri
-    return iri_to_uri(iri)
-def _decode_idna(domain: str) -> str:
-    try:
-        data = domain.encode("ascii")
-    except UnicodeEncodeError:
-        # If the domain is not ASCII, it's decoded already.
-        return domain
-    try:
-        # Try decoding in one shot.
-        return data.decode("idna")
-    except UnicodeDecodeError:
-        pass
-    # Decode each part separately, leaving invalid parts as punycode.
-    parts = []
-    for part in data.split(b"."):
-        try:
-            parts.append(part.decode("idna"))
-        except UnicodeDecodeError:
-            parts.append(part.decode("ascii"))
-    return ".".join(parts)
-def _urlencode(query: t.Mapping[str, str] | t.Iterable[tuple[str, str]]) -> str:
-    items = [x for x in iter_multi_items(query) if x[1] is not None]
-    # safe = https://url.spec.whatwg.org/#percent-encoded-bytes
-    return urlencode(items, safe="!$'()*,/:;?@")

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

@@ -1,47 +0,0 @@
-from __future__ import annotations
-class UserAgent:
-    """Represents a parsed user agent header value.
-    The default implementation does no parsing, only the :attr:`string`
-    attribute is set. A subclass may parse the string to set the
-    common attributes or expose other information. Set
-    :attr:`werkzeug.wrappers.Request.user_agent_class` to use a
-    subclass.
-    :param string: The header value to parse.
-    .. versionadded:: 2.0
-        This replaces the previous ``useragents`` module, but does not
-        provide a built-in parser.
-    """
-    platform: str | None = None
-    """The OS name, if it could be parsed from the string."""
-    browser: str | None = None
-    """The browser name, if it could be parsed from the string."""
-    version: str | None = None
-    """The browser version, if it could be parsed from the string."""
-    language: str | None = None
-    """The browser language, if it could be parsed from the string."""
-    def __init__(self, string: str) -> None:
-        self.string: str = string
-        """The original header value."""
-    def __repr__(self) -> str:
-        return f"<{type(self).__name__} {self.browser}/{self.version}>"
-    def __str__(self) -> str:
-        return self.string
-    def __bool__(self) -> bool:
-        return bool(self.browser)
-    def to_header(self) -> str:
-        """Convert to a header value."""
-        return self.string