/usr/lib/imh-dnskeyapi/venv/lib/python3.13/site-packages/werkzeug/

/usr/lib/imh-dnskeyapi/venv/lib/python3.13/site-packages/werkzeug

Name	Size	Mode	Actions
datastructures/	-	0755	rm
debug/	-	0755	rm
middleware/	-	0755	rm
routing/	-	0755	rm
sansio/	-	0755	rm
wrappers/	-	0755	rm
__pycache__/	-	0755	rm
exceptions.py	26455	0644	edit dl rm
formparser.py	15847	0644	edit dl rm
http.py	44880	0644	edit dl rm
local.py	22492	0644	edit dl rm
py.typed	0	0644	edit dl rm
security.py	5581	0644	edit dl rm
serving.py	39857	0644	edit dl rm
test.py	52795	0644	edit dl rm
testapp.py	6332	0644	edit dl rm
urls.py	6430	0644	edit dl rm
user_agent.py	1416	0644	edit dl rm
utils.py	24725	0644	edit dl rm
wsgi.py	20894	0644	edit dl rm
_internal.py	5545	0644	edit dl rm
_reloader.py	15429	0644	edit dl rm
__init__.py	165	0644	edit dl rm

Edit: /usr/lib/imh-dnskeyapi/venv/lib/python3.13/site-packages/werkzeug/testapp.py (6332B)

"""A small application that can be used to test a WSGI server and check
it for WSGI compliance.
"""

from __future__ import annotations

import importlib.metadata
import os
import sys
import typing as t
from textwrap import wrap

from markupsafe import escape

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():
        css = []
        if virtual:
            css.append("virtual")
        if expanded:
            css.append("exp")
        class_str = f' class="{" ".join(css)}"' if css else ""
        sys_path.append(f"<li{class_str}>{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": _get_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")

_werkzeug_version = ""

def _get_werkzeug_version() -> str:
    global _werkzeug_version

if not _werkzeug_version:
        _werkzeug_version = importlib.metadata.version("werkzeug")

return _werkzeug_version

if __name__ == "__main__":
    from .serving import run_simple

run_simple("localhost", 5000, test_app, use_reloader=True)

"""A small application that can be used to test a WSGI server and check it for WSGI compliance. """ from __future__ import annotations import importlib.metadata import os import sys import typing as t from textwrap import wrap from markupsafe import escape from .wrappers.request import Request from .wrappers.response import Response TEMPLATE = """\ WSGI Information

WSGI Information

This page displays all available information about the WSGI server and the underlying Python interpreter.

Python Interpreter

Python Version	%(python_version)s
Platform	%(platform)s [%(os)s]
API Version	%(api_version)s
Byteorder	%(byteorder)s
Werkzeug Version	%(werkzeug_version)s

WSGI Environment

%(wsgi_env)s

Installed Eggs

The following python packages were installed on the system as Python eggs:

%(python_eggs)s

System Path

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.

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.

%(sys_path)s

""" 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"

{escape(egg.project_name)} [{escape(version)}]" ) 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"{escape(key)}{value}") sys_path = [] for item, virtual, expanded in iter_sys_path(): css = [] if virtual: css.append("virtual") if expanded: css.append("exp") class_str = f' class="{" ".join(css)}"' if css else "" sys_path.append(f"{escape(item)}") context = { "python_version": "
".join(escape(sys.version).splitlines()), "platform": escape(sys.platform), "os": escape(os.name), "api_version": sys.api_version, "byteorder": sys.byteorder, "werkzeug_version": _get_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") _werkzeug_version = "" def _get_werkzeug_version() -> str: global _werkzeug_version if not _werkzeug_version: _werkzeug_version = importlib.metadata.version("werkzeug") return _werkzeug_version if __name__ == "__main__": from .serving import run_simple run_simple("localhost", 5000, test_app, use_reloader=True)