From 2c94c19b4e3da260295d31be6ebb949be8e225dd Mon Sep 17 00:00:00 2001
From: Polina <polinafresh15@gmail.com>
Date: Thu, 2 Jul 2026 18:42:18 +0000
Subject: [PATCH] =?UTF-8?q?=D0=97=D0=B0=D0=B3=D1=80=D1=83=D0=B7=D0=B8?=
 =?UTF-8?q?=D1=82=D1=8C=20=D1=84=D0=B0=D0=B9=D0=BB=D1=8B=20=D0=B2=20=C2=AB?=
 =?UTF-8?q?venv/Lib/site-packages/markupsafe=C2=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 venv/Lib/site-packages/markupsafe/__init__.py | 396 ++++++++++++++++++
 venv/Lib/site-packages/markupsafe/_native.py  |   8 +
 venv/Lib/site-packages/markupsafe/_speedups.c | 200 +++++++++
 .../markupsafe/_speedups.cp314-win_amd64.pyd  | Bin 0 -> 13312 bytes
 .../site-packages/markupsafe/_speedups.pyi    |   1 +
 5 files changed, 605 insertions(+)
 create mode 100644 venv/Lib/site-packages/markupsafe/__init__.py
 create mode 100644 venv/Lib/site-packages/markupsafe/_native.py
 create mode 100644 venv/Lib/site-packages/markupsafe/_speedups.c
 create mode 100644 venv/Lib/site-packages/markupsafe/_speedups.cp314-win_amd64.pyd
 create mode 100644 venv/Lib/site-packages/markupsafe/_speedups.pyi

diff --git a/venv/Lib/site-packages/markupsafe/__init__.py b/venv/Lib/site-packages/markupsafe/__init__.py
new file mode 100644
index 0000000..886f2a0
--- /dev/null
+++ b/venv/Lib/site-packages/markupsafe/__init__.py
@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import string
+import typing as t
+
+try:
+    from ._speedups import _escape_inner
+except ImportError:
+    from ._native import _escape_inner
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+
+class _HasHTML(t.Protocol):
+    def __html__(self, /) -> str: ...
+
+
+class _TPEscape(t.Protocol):
+    def __call__(self, s: t.Any, /) -> Markup: ...
+
+
+def escape(s: t.Any, /) -> Markup:
+    """Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in
+    the string with HTML-safe sequences. Use this if you need to display
+    text that might contain such characters in HTML.
+
+    If the object has an ``__html__`` method, it is called and the
+    return value is assumed to already be safe for HTML.
+
+    :param s: An object to be converted to a string and escaped.
+    :return: A :class:`Markup` string with the escaped text.
+    """
+    # If the object is already a plain string, skip __html__ check and string
+    # conversion. This is the most common use case.
+    # Use type(s) instead of s.__class__ because a proxy object may be reporting
+    # the __class__ of the proxied value.
+    if type(s) is str:
+        return Markup(_escape_inner(s))
+
+    if hasattr(s, "__html__"):
+        return Markup(s.__html__())
+
+    return Markup(_escape_inner(str(s)))
+
+
+def escape_silent(s: t.Any | None, /) -> Markup:
+    """Like :func:`escape` but treats ``None`` as the empty string.
+    Useful with optional values, as otherwise you get the string
+    ``'None'`` when the value is ``None``.
+
+    >>> escape(None)
+    Markup('None')
+    >>> escape_silent(None)
+    Markup('')
+    """
+    if s is None:
+        return Markup()
+
+    return escape(s)
+
+
+def soft_str(s: t.Any, /) -> str:
+    """Convert an object to a string if it isn't already. This preserves
+    a :class:`Markup` string rather than converting it back to a basic
+    string, so it will still be marked as safe and won't be escaped
+    again.
+
+    >>> value = escape("<User 1>")
+    >>> value
+    Markup('&lt;User 1&gt;')
+    >>> escape(str(value))
+    Markup('&amp;lt;User 1&amp;gt;')
+    >>> escape(soft_str(value))
+    Markup('&lt;User 1&gt;')
+    """
+    if not isinstance(s, str):
+        return str(s)
+
+    return s
+
+
+class Markup(str):
+    """A string that is ready to be safely inserted into an HTML or XML
+    document, either because it was escaped or because it was marked
+    safe.
+
+    Passing an object to the constructor converts it to text and wraps
+    it to mark it safe without escaping. To escape the text, use the
+    :meth:`escape` class method instead.
+
+    >>> Markup("Hello, <em>World</em>!")
+    Markup('Hello, <em>World</em>!')
+    >>> Markup(42)
+    Markup('42')
+    >>> Markup.escape("Hello, <em>World</em>!")
+    Markup('Hello &lt;em&gt;World&lt;/em&gt;!')
+
+    This implements the ``__html__()`` interface that some frameworks
+    use. Passing an object that implements ``__html__()`` will wrap the
+    output of that method, marking it safe.
+
+    >>> class Foo:
+    ...     def __html__(self):
+    ...         return '<a href="/foo">foo</a>'
+    ...
+    >>> Markup(Foo())
+    Markup('<a href="/foo">foo</a>')
+
+    This is a subclass of :class:`str`. It has the same methods, but
+    escapes their arguments and returns a ``Markup`` instance.
+
+    >>> Markup("<em>%s</em>") % ("foo & bar",)
+    Markup('<em>foo &amp; bar</em>')
+    >>> Markup("<em>Hello</em> ") + "<foo>"
+    Markup('<em>Hello</em> &lt;foo&gt;')
+    """
+
+    __slots__ = ()
+
+    def __new__(
+        cls, object: t.Any = "", encoding: str | None = None, errors: str = "strict"
+    ) -> te.Self:
+        if hasattr(object, "__html__"):
+            object = object.__html__()
+
+        if encoding is None:
+            return super().__new__(cls, object)
+
+        return super().__new__(cls, object, encoding, errors)
+
+    def __html__(self, /) -> te.Self:
+        return self
+
+    def __add__(self, value: str | _HasHTML, /) -> te.Self:
+        if isinstance(value, str) or hasattr(value, "__html__"):
+            return self.__class__(super().__add__(self.escape(value)))
+
+        return NotImplemented
+
+    def __radd__(self, value: str | _HasHTML, /) -> te.Self:
+        if isinstance(value, str) or hasattr(value, "__html__"):
+            return self.escape(value).__add__(self)
+
+        return NotImplemented
+
+    def __mul__(self, value: t.SupportsIndex, /) -> te.Self:
+        return self.__class__(super().__mul__(value))
+
+    def __rmul__(self, value: t.SupportsIndex, /) -> te.Self:
+        return self.__class__(super().__mul__(value))
+
+    def __mod__(self, value: t.Any, /) -> te.Self:
+        if isinstance(value, tuple):
+            # a tuple of arguments, each wrapped
+            value = tuple(_MarkupEscapeHelper(x, self.escape) for x in value)
+        elif hasattr(type(value), "__getitem__") and not isinstance(value, str):
+            # a mapping of arguments, wrapped
+            value = _MarkupEscapeHelper(value, self.escape)
+        else:
+            # a single argument, wrapped with the helper and a tuple
+            value = (_MarkupEscapeHelper(value, self.escape),)
+
+        return self.__class__(super().__mod__(value))
+
+    def __repr__(self, /) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+    def join(self, iterable: cabc.Iterable[str | _HasHTML], /) -> te.Self:
+        return self.__class__(super().join(map(self.escape, iterable)))
+
+    def split(  # type: ignore[override]
+        self, /, sep: str | None = None, maxsplit: t.SupportsIndex = -1
+    ) -> list[te.Self]:
+        return [self.__class__(v) for v in super().split(sep, maxsplit)]
+
+    def rsplit(  # type: ignore[override]
+        self, /, sep: str | None = None, maxsplit: t.SupportsIndex = -1
+    ) -> list[te.Self]:
+        return [self.__class__(v) for v in super().rsplit(sep, maxsplit)]
+
+    def splitlines(  # type: ignore[override]
+        self, /, keepends: bool = False
+    ) -> list[te.Self]:
+        return [self.__class__(v) for v in super().splitlines(keepends)]
+
+    def unescape(self, /) -> str:
+        """Convert escaped markup back into a text string. This replaces
+        HTML entities with the characters they represent.
+
+        >>> Markup("Main &raquo; <em>About</em>").unescape()
+        'Main » <em>About</em>'
+        """
+        from html import unescape
+
+        return unescape(str(self))
+
+    def striptags(self, /) -> str:
+        """:meth:`unescape` the markup, remove tags, and normalize
+        whitespace to single spaces.
+
+        >>> Markup("Main &raquo;\t<em>About</em>").striptags()
+        'Main » About'
+        """
+        value = str(self)
+
+        # Look for comments then tags separately. Otherwise, a comment that
+        # contains a tag would end early, leaving some of the comment behind.
+
+        # keep finding comment start marks
+        while (start := value.find("<!--")) != -1:
+            # find a comment end mark beyond the start, otherwise stop
+            if (end := value.find("-->", start)) == -1:
+                break
+
+            value = f"{value[:start]}{value[end + 3 :]}"
+
+        # remove tags using the same method
+        while (start := value.find("<")) != -1:
+            if (end := value.find(">", start)) == -1:
+                break
+
+            value = f"{value[:start]}{value[end + 1 :]}"
+
+        # collapse spaces
+        value = " ".join(value.split())
+        return self.__class__(value).unescape()
+
+    @classmethod
+    def escape(cls, s: t.Any, /) -> te.Self:
+        """Escape a string. Calls :func:`escape` and ensures that for
+        subclasses the correct type is returned.
+        """
+        rv = escape(s)
+
+        if rv.__class__ is not cls:
+            return cls(rv)
+
+        return rv  # type: ignore[return-value]
+
+    def __getitem__(self, key: t.SupportsIndex | slice, /) -> te.Self:
+        return self.__class__(super().__getitem__(key))
+
+    def capitalize(self, /) -> te.Self:
+        return self.__class__(super().capitalize())
+
+    def title(self, /) -> te.Self:
+        return self.__class__(super().title())
+
+    def lower(self, /) -> te.Self:
+        return self.__class__(super().lower())
+
+    def upper(self, /) -> te.Self:
+        return self.__class__(super().upper())
+
+    def replace(self, old: str, new: str, count: t.SupportsIndex = -1, /) -> te.Self:
+        return self.__class__(super().replace(old, self.escape(new), count))
+
+    def ljust(self, width: t.SupportsIndex, fillchar: str = " ", /) -> te.Self:
+        return self.__class__(super().ljust(width, self.escape(fillchar)))
+
+    def rjust(self, width: t.SupportsIndex, fillchar: str = " ", /) -> te.Self:
+        return self.__class__(super().rjust(width, self.escape(fillchar)))
+
+    def lstrip(self, chars: str | None = None, /) -> te.Self:
+        return self.__class__(super().lstrip(chars))
+
+    def rstrip(self, chars: str | None = None, /) -> te.Self:
+        return self.__class__(super().rstrip(chars))
+
+    def center(self, width: t.SupportsIndex, fillchar: str = " ", /) -> te.Self:
+        return self.__class__(super().center(width, self.escape(fillchar)))
+
+    def strip(self, chars: str | None = None, /) -> te.Self:
+        return self.__class__(super().strip(chars))
+
+    def translate(
+        self,
+        table: cabc.Mapping[int, str | int | None],  # type: ignore[override]
+        /,
+    ) -> str:
+        return self.__class__(super().translate(table))
+
+    def expandtabs(self, /, tabsize: t.SupportsIndex = 8) -> te.Self:
+        return self.__class__(super().expandtabs(tabsize))
+
+    def swapcase(self, /) -> te.Self:
+        return self.__class__(super().swapcase())
+
+    def zfill(self, width: t.SupportsIndex, /) -> te.Self:
+        return self.__class__(super().zfill(width))
+
+    def casefold(self, /) -> te.Self:
+        return self.__class__(super().casefold())
+
+    def removeprefix(self, prefix: str, /) -> te.Self:
+        return self.__class__(super().removeprefix(prefix))
+
+    def removesuffix(self, suffix: str) -> te.Self:
+        return self.__class__(super().removesuffix(suffix))
+
+    def partition(self, sep: str, /) -> tuple[te.Self, te.Self, te.Self]:
+        left, sep, right = super().partition(sep)
+        cls = self.__class__
+        return cls(left), cls(sep), cls(right)
+
+    def rpartition(self, sep: str, /) -> tuple[te.Self, te.Self, te.Self]:
+        left, sep, right = super().rpartition(sep)
+        cls = self.__class__
+        return cls(left), cls(sep), cls(right)
+
+    def format(self, *args: t.Any, **kwargs: t.Any) -> te.Self:
+        formatter = EscapeFormatter(self.escape)
+        return self.__class__(formatter.vformat(self, args, kwargs))
+
+    def format_map(
+        self,
+        mapping: cabc.Mapping[str, t.Any],  # type: ignore[override]
+        /,
+    ) -> te.Self:
+        formatter = EscapeFormatter(self.escape)
+        return self.__class__(formatter.vformat(self, (), mapping))
+
+    def __html_format__(self, format_spec: str, /) -> te.Self:
+        if format_spec:
+            raise ValueError("Unsupported format specification for Markup.")
+
+        return self
+
+
+class EscapeFormatter(string.Formatter):
+    __slots__ = ("escape",)
+
+    def __init__(self, escape: _TPEscape) -> None:
+        self.escape: _TPEscape = escape
+        super().__init__()
+
+    def format_field(self, value: t.Any, format_spec: str) -> str:
+        if hasattr(value, "__html_format__"):
+            rv = value.__html_format__(format_spec)
+        elif hasattr(value, "__html__"):
+            if format_spec:
+                raise ValueError(
+                    f"Format specifier {format_spec} given, but {type(value)} does not"
+                    " define __html_format__. A class that defines __html__ must define"
+                    " __html_format__ to work with format specifiers."
+                )
+            rv = value.__html__()
+        else:
+            # We need to make sure the format spec is str here as
+            # otherwise the wrong callback methods are invoked.
+            rv = super().format_field(value, str(format_spec))
+        return str(self.escape(rv))
+
+
+class _MarkupEscapeHelper:
+    """Helper for :meth:`Markup.__mod__`."""
+
+    __slots__ = ("obj", "escape")
+
+    def __init__(self, obj: t.Any, escape: _TPEscape) -> None:
+        self.obj: t.Any = obj
+        self.escape: _TPEscape = escape
+
+    def __getitem__(self, key: t.Any, /) -> te.Self:
+        return self.__class__(self.obj[key], self.escape)
+
+    def __str__(self, /) -> str:
+        return str(self.escape(self.obj))
+
+    def __repr__(self, /) -> str:
+        return str(self.escape(repr(self.obj)))
+
+    def __int__(self, /) -> int:
+        return int(self.obj)
+
+    def __float__(self, /) -> float:
+        return float(self.obj)
+
+
+def __getattr__(name: str) -> t.Any:
+    if name == "__version__":
+        import importlib.metadata
+        import warnings
+
+        warnings.warn(
+            "The '__version__' attribute is deprecated and will be removed in"
+            " MarkupSafe 3.1. Use feature detection, or"
+            ' `importlib.metadata.version("markupsafe")`, instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return importlib.metadata.version("markupsafe")
+
+    raise AttributeError(name)
diff --git a/venv/Lib/site-packages/markupsafe/_native.py b/venv/Lib/site-packages/markupsafe/_native.py
new file mode 100644
index 0000000..177d446
--- /dev/null
+++ b/venv/Lib/site-packages/markupsafe/_native.py
@@ -0,0 +1,8 @@
+def _escape_inner(s: str, /) -> str:
+    return (
+        s.replace("&", "&amp;")
+        .replace(">", "&gt;")
+        .replace("<", "&lt;")
+        .replace("'", "&#39;")
+        .replace('"', "&#34;")
+    )
diff --git a/venv/Lib/site-packages/markupsafe/_speedups.c b/venv/Lib/site-packages/markupsafe/_speedups.c
new file mode 100644
index 0000000..2ee271d
--- /dev/null
+++ b/venv/Lib/site-packages/markupsafe/_speedups.c
@@ -0,0 +1,200 @@
+#include <Python.h>
+
+#define GET_DELTA(inp, inp_end, delta) \
+	while (inp < inp_end) { \
+		switch (*inp++) { \
+		case '"': \
+		case '\'': \
+		case '&': \
+			delta += 4; \
+			break; \
+		case '<': \
+		case '>': \
+			delta += 3; \
+			break; \
+		} \
+	}
+
+#define DO_ESCAPE(inp, inp_end, outp) \
+	{ \
+		Py_ssize_t ncopy = 0; \
+		while (inp < inp_end) { \
+			switch (*inp) { \
+			case '"': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '4'; \
+				*outp++ = ';'; \
+				break; \
+			case '\'': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '9'; \
+				*outp++ = ';'; \
+				break; \
+			case '&': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'a'; \
+				*outp++ = 'm'; \
+				*outp++ = 'p'; \
+				*outp++ = ';'; \
+				break; \
+			case '<': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'l'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			case '>': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'g'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			default: \
+				ncopy++; \
+			} \
+			inp++; \
+		} \
+		memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+	}
+
+static PyObject*
+escape_unicode_kind1(PyUnicodeObject *in)
+{
+	Py_UCS1 *inp = PyUnicode_1BYTE_DATA(in);
+	Py_UCS1 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS1 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta,
+						PyUnicode_IS_ASCII(in) ? 127 : 255);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_1BYTE_DATA(in);
+	outp = PyUnicode_1BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode_kind2(PyUnicodeObject *in)
+{
+	Py_UCS2 *inp = PyUnicode_2BYTE_DATA(in);
+	Py_UCS2 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS2 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 65535);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_2BYTE_DATA(in);
+	outp = PyUnicode_2BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+
+static PyObject*
+escape_unicode_kind4(PyUnicodeObject *in)
+{
+	Py_UCS4 *inp = PyUnicode_4BYTE_DATA(in);
+	Py_UCS4 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS4 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 1114111);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_4BYTE_DATA(in);
+	outp = PyUnicode_4BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode(PyObject *self, PyObject *s)
+{
+	if (!PyUnicode_Check(s))
+		return NULL;
+
+    // This check is no longer needed in Python 3.12.
+	if (PyUnicode_READY(s))
+		return NULL;
+
+	switch (PyUnicode_KIND(s)) {
+	case PyUnicode_1BYTE_KIND:
+		return escape_unicode_kind1((PyUnicodeObject*) s);
+	case PyUnicode_2BYTE_KIND:
+		return escape_unicode_kind2((PyUnicodeObject*) s);
+	case PyUnicode_4BYTE_KIND:
+		return escape_unicode_kind4((PyUnicodeObject*) s);
+	}
+	assert(0);  /* shouldn't happen */
+	return NULL;
+}
+
+static PyMethodDef module_methods[] = {
+	{"_escape_inner", (PyCFunction)escape_unicode, METH_O, NULL},
+	{NULL, NULL, 0, NULL}  /* Sentinel */
+};
+
+static PyModuleDef_Slot module_slots[] = {
+#ifdef Py_mod_multiple_interpreters  // Python 3.12+
+	{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
+#endif
+#ifdef Py_mod_gil  // Python 3.13+
+	{Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+	{0, NULL}  /* Sentinel */
+};
+
+static struct PyModuleDef module_definition = {
+	.m_base = PyModuleDef_HEAD_INIT,
+	.m_name = "markupsafe._speedups",
+	.m_size = 0,
+	.m_methods = module_methods,
+	.m_slots = module_slots,
+};
+
+PyMODINIT_FUNC
+PyInit__speedups(void)
+{
+	return PyModuleDef_Init(&module_definition);
+}
diff --git a/venv/Lib/site-packages/markupsafe/_speedups.cp314-win_amd64.pyd b/venv/Lib/site-packages/markupsafe/_speedups.cp314-win_amd64.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..151c91b4cacd920d4ddbf4115fbdc03d41355d77
GIT binary patch
literal 13312
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
G<o^>`$_6t4

literal 0
HcmV?d00001

diff --git a/venv/Lib/site-packages/markupsafe/_speedups.pyi b/venv/Lib/site-packages/markupsafe/_speedups.pyi
new file mode 100644
index 0000000..d793538
--- /dev/null
+++ b/venv/Lib/site-packages/markupsafe/_speedups.pyi
@@ -0,0 +1 @@
+def _escape_inner(s: str, /) -> str: ...