### MarkupSafe Installation

Source: https://context7.com/pallets/markupsafe/llms.txt

Instructions on how to install the MarkupSafe library using pip.

```APIDOC
## Installation

Install MarkupSafe via pip.

```bash
pip install -U MarkupSafe
```
```

--------------------------------

### Install MarkupSafe using pip

Source: https://github.com/pallets/markupsafe/blob/main/docs/index.md

Provides the command to install or update the MarkupSafe library using pip, the standard package installer for Python.

```text
pip install -U MarkupSafe
```

--------------------------------

### Implement custom HTML formatting for objects

Source: https://github.com/pallets/markupsafe/blob/main/docs/formatting.md

This example demonstrates how to implement the __html_format__ and __html__ methods within a class to define custom rendering logic for MarkupSafe. It shows how to handle specific format specifiers like 'link' and ensure proper escaping of user-provided content.

```python
class User(object):
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html_format__(self, format_spec):
        if format_spec == "link":
            return Markup(
                '<a href="/user/{}">{}</a>'
            ).format(self.id, self.__html__())
        elif format_spec:
            raise ValueError("Invalid format spec")
        return self.__html__()

    def __html__(self):
        return Markup(
            '<span class="user">{0}</span>'
        ).format(self.name)
```

--------------------------------

### Define custom HTML representation with __html__

Source: https://github.com/pallets/markupsafe/blob/main/docs/html.md

This example demonstrates how to create a class that implements the __html__ method to return a safe HTML string. It shows both the class definition and the resulting behavior when passed to the Markup constructor.

```python
class Image:
    def __init__(self, url):
        self.url = url

    def __html__(self):
        return f'<img src="{self.url}">'
```

```pycon
>>> img = Image("/static/logo.png")
>>> Markup(img)
Markup('<img src="/static/logo.png">')
```

--------------------------------

### Securely escaping user data within __html__

Source: https://github.com/pallets/markupsafe/blob/main/docs/html.md

This example illustrates how to safely include user-provided data within an __html__ method by using the escape function. This ensures that while the tag structure is trusted, the dynamic content remains sanitized.

```python
class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html__(self):
        return f'<a href="/user/{self.id}">{escape(self.name)}</a>'
```

```pycon
>>> user = User(3, "<script>")
>>> escape(user)
Markup('<a href="/users/3">&lt;script&gt;</a>')
```

--------------------------------

### Implementing __html__ Protocol

Source: https://github.com/pallets/markupsafe/blob/main/docs/html.md

How to define custom classes that integrate with MarkupSafe's escaping mechanisms by implementing the __html__ method.

```APIDOC
## __html__ Protocol Implementation

### Description
Objects that implement the `__html__` method are recognized by `MarkupSafe.escape()` and the `Markup` class. When these functions encounter an object with this method, they call it instead of converting the object to a standard string, assuming the returned value is safe HTML.

### Usage
Define an `__html__` method within your class that returns a string containing the desired HTML representation.

### Example Implementation
```python
class Image:
    def __init__(self, url):
        self.url = url

    def __html__(self):
        return f'<img src="{self.url}">'
```

### Security Note
When implementing `__html__`, ensure that any user-provided data included in the output is manually escaped using `markupsafe.escape()` to prevent Cross-Site Scripting (XSS) vulnerabilities.

### Security Example
```python
from markupsafe import escape

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html__(self):
        return f'<a href="/user/{self.id}">{escape(self.name)}</a>'
```
```

--------------------------------

### Implement __html_format__ for Custom HTML Formatting in Python

Source: https://context7.com/pallets/markupsafe/llms.txt

Demonstrates how to implement the `__html_format__` method in a Python class to control its HTML representation based on format specifiers. This allows for custom rendering, such as creating links or badges, when the object is used with `Markup.format()`.

```python
from markupsafe import Markup, escape

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html_format__(self, format_spec):
        if format_spec == "link":
            # Return a clickable link
            return Markup('<a href="/user/{}">{}</a>').format(
                self.id, self.__html__()
            )
        elif format_spec == "badge":
            # Return a styled badge
            return Markup('<span class="badge">{}</span>').format(
                escape(self.name)
            )
        elif format_spec:
            raise ValueError(f"Invalid format spec: {format_spec}")
        return self.__html__()

    def __html__(self):
        return Markup('<span class="user">{}</span>').format(
            escape(self.name)
        )

user = User(3, "<Admin>")

# Default format
print(Markup("User: {}").format(user))
# Output: User: <span class="user">&lt;Admin&gt;</span>

# Link format
print(Markup("Profile: {user:link}").format(user=user))
# Output: Profile: <a href="/user/3"><span class="user">&lt;Admin&gt;</span></a>

# Badge format
print(Markup("Role: {user:badge}").format(user=user))
# Output: Role: <span class="badge">&lt;Admin&gt;</span>
```

--------------------------------

### Format Markup objects with custom specifiers

Source: https://github.com/pallets/markupsafe/blob/main/docs/formatting.md

Demonstrates using the Markup class to format objects with custom specifiers. It shows how the defined __html_format__ method is invoked during the string formatting process.

```pycon
>>> user = User(3, "<script>")
>>> escape(user)
Markup('<span class="user">&lt;script&gt;</span>')
>>> Markup("<p>User: {user:link}").format(user=user)
Markup('<p>User: <a href="/user/3"><span class="user">&lt;script&gt;</span></a>')
```

--------------------------------

### __html_format__ Protocol

Source: https://context7.com/pallets/markupsafe/llms.txt

Learn how to implement the __html_format__ method in custom classes to control their HTML representation based on format specifiers when used with Markup.format().

```APIDOC
## __html_format__ Protocol for Custom Formatting

Classes can implement `__html_format__()` to control how they are formatted when used with `Markup.format()`. This method receives the format specifier and can return different HTML representations based on it.

### Method
`__html_format__(self, format_spec)`

### Parameters
- **format_spec** (string) - The format specifier passed to `Markup.format()`.

### Request Example
```python
from markupsafe import Markup, escape

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html_format__(self, format_spec):
        if format_spec == "link":
            return Markup('<a href="/user/{}">{}</a>').format(
                self.id, self.__html__()
            )
        elif format_spec == "badge":
            return Markup('<span class="badge">{}</span>').format(
                escape(self.name)
            )
        elif format_spec:
            raise ValueError(f"Invalid format spec: {format_spec}")
        return self.__html__()

    def __html__(self):
        return Markup('<span class="user">{}</span>').format(
            escape(self.name)
        )

user = User(3, "<Admin>")

# Link format
print(Markup("Profile: {user:link}").format(user=user))
# Output: Profile: <a href="/user/3"><span class="user">&lt;Admin&gt;</span></a>

# Badge format
print(Markup("Role: {user:badge}").format(user=user))
# Output: Role: <span class="badge">&lt;Admin&gt;</span>
```

### Response Example
```
<a href="/user/3"><span class="user">&lt;Admin&gt;</span></a>
```
```

--------------------------------

### Python: Escaping and Marking Text with MarkupSafe

Source: https://github.com/pallets/markupsafe/blob/main/README.md

Demonstrates how to use MarkupSafe's `escape` function to replace special HTML characters and the `Markup` class to mark text as safe, preventing further escaping. It also shows how `Markup` objects handle string formatting.

```python
from markupsafe import Markup, escape

# escape replaces special characters and wraps in Markup
escape("<script>alert(document.cookie);</script>")

# wrap in Markup to mark text "safe" and prevent escaping
Markup("<strong>Hello</strong>")

escape(Markup("<strong>Hello</strong>"))

# Markup is a str subclass
# methods and operators escape their arguments
template = Markup("Hello <em>{name}</em>")
template.format(name='"World"')

```

--------------------------------

### Perform printf-style formatting with Markup

Source: https://github.com/pallets/markupsafe/blob/main/docs/formatting.md

Shows how to use standard Python printf-style formatting with Markup strings. The content is automatically escaped while maintaining the structure of the format string.

```pycon
>>> user = User(3, "<script>")
>>> Markup('<a href="/user/%d">%s</a>') % (user.id, user.name)
Markup('<a href="/user/3">&lt;script&gt;</a>')
```

--------------------------------

### Strip HTML tags with striptags()

Source: https://context7.com/pallets/markupsafe/llms.txt

Shows how to remove all HTML tags and normalize whitespace from a Markup object to produce plain text.

```python
from markupsafe import Markup

html_content = Markup("Main &raquo;\t<em>About</em>")
plain = html_content.striptags()
print(plain)

complex_html = Markup("""
    <div class="header">
        <h1>Welcome</h1>
        <!-- Navigation comment -->
        <nav><a href="/">Home</a> | <a href="/about">About</a></nav>
    </div>
""")
print(complex_html.striptags())
```

--------------------------------

### Markup String Methods

Source: https://context7.com/pallets/markupsafe/llms.txt

Explains how standard Python string methods, when called on a Markup object, return Markup instances, preserving safety and automatically escaping replacements.

```APIDOC
## Markup String Methods

All standard string methods like `split()`, `rsplit()`, `splitlines()`, `replace()`, `strip()`, `lower()`, `upper()`, etc. return `Markup` instances, preserving the safety status of the text.

### Method
Standard string methods (e.g., `split()`, `upper()`, `replace()`)

### Parameters
Parameters depend on the specific string method being called.

### Request Example
```python
from markupsafe import Markup

html = Markup("<p>Hello, World!</p>")

# split() returns list of Markup
parts = html.split(",")
print(parts)
# Output: [Markup('<p>Hello'), Markup(' World!</p>')]
print(type(parts[0]))
# Output: <class 'markupsafe.Markup'>

# Case transformation
print(html.upper())
# Output: <P>HELLO, WORLD!</P>

# replace() escapes the replacement string
template = Markup("<div>PLACEHOLDER</div>")
result = template.replace("PLACEHOLDER", "<user input>")
print(result)
# Output: <div>&lt;user input&gt;</div>

# Slicing preserves Markup type
print(html[3:10])
# Output: >Hello,
print(type(html[3:10]))
# Output: <class 'markupsafe.Markup'>
```

### Response Example
```
[Markup("<p>Hello"), Markup(" World!</p>")]
<class 'markupsafe.Markup'>
<P>HELLO, WORLD!</P>
<div>&lt;user input&gt;</div>
>Hello,
<class 'markupsafe.Markup'>
```
```

--------------------------------

### Manage safe strings with Markup class

Source: https://context7.com/pallets/markupsafe/llms.txt

Shows how to use the Markup class to define trusted HTML strings that are automatically escaped when concatenated with unsafe content.

```python
from markupsafe import Markup

trusted_html = Markup("<strong>Bold</strong>")
print(trusted_html)

untrusted = Markup.escape("<script>bad</script>")
print(untrusted)

safe_text = Markup("<em>Hello</em> ")
result = safe_text + "<script>alert('xss')</script>"
print(result)

html = Markup("<p>hello world</p>")
print(html.upper())
```

--------------------------------

### Convert HTML entities with unescape()

Source: https://context7.com/pallets/markupsafe/llms.txt

Demonstrates how to revert HTML entities back to their original character representations using the unescape method.

```python
from markupsafe import Markup

escaped = Markup("Main &raquo; &lt;em&gt;About&lt;/em&gt;")
plain_text = escaped.unescape()
print(plain_text)

entities = Markup("&amp; &lt; &gt; &quot; &#39; &copy;")
print(entities.unescape())
```

--------------------------------

### Markup.join() Method

Source: https://context7.com/pallets/markupsafe/llms.txt

Demonstrates how to use the Markup.join() method to safely concatenate an iterable of strings with a Markup separator, ensuring proper HTML escaping.

```APIDOC
## Markup.join() Method

The `join()` method joins an iterable of strings with the `Markup` separator, escaping each element. This is useful for safely building lists of HTML elements from potentially unsafe strings.

### Method
`Markup.join(iterable)`

### Parameters
- **iterable** (iterable) - An iterable of strings to join.

### Request Example
```python
from markupsafe import Markup

# Join list items with separator, escaping each item
items = ["Home", "About <us>", "Contact & Info"]
nav = Markup(" | ").join(items)
print(nav)
# Output: Home | About &lt;us&gt; | Contact &amp; Info

# Build HTML lists safely
list_items = ["<script>", "Normal Item", "Item & More"]
html_list = Markup("<li>") + Markup("</li><li>").join(list_items) + Markup("</li>")
print(Markup("<ul>") + html_list + Markup("</ul>"))
# Output: <ul><li>&lt;script&gt;</li><li>Normal Item</li><li>Item &amp; More</li></ul>
```

### Response Example
```
Home | About &lt;us&gt; | Contact &amp; Info
```
```

--------------------------------

### String Formatting with Markup in MarkupSafe

Source: https://context7.com/pallets/markupsafe/llms.txt

The Markup class in MarkupSafe supports both the format() method and printf-style (%) formatting for safe string interpolation. Values inserted into a Markup template are automatically escaped to prevent XSS attacks.

```python
from markupsafe import Markup, escape

# format() method escapes inserted values
template = Markup("<p>Hello, <strong>{name}</strong>!</p>")
result = template.format(name="<script>alert('xss')</script>")
print(result)
# Output: <p>Hello, <strong>&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;</strong>!</p>

# Printf-style formatting also escapes values
user_name = "<script>"
user_id = 42
html = Markup('<a href="/user/%d">%s</a>') % (user_id, user_name)
print(html)
# Output: <a href="/user/42">&lt;script&gt;</a>

# Multiple placeholders with format()
row = Markup("<tr><td>{name}</td><td>{email}</td></tr>")
print(row.format(name="John <Doe>", email="john@example.com"))
# Output: <tr><td>John &lt;Doe&gt;</td><td>john@example.com</td></tr>

# Keyword arguments work too
link = Markup('<a href="{url}">{text}</a>')
print(link.format(url="/path?a=1&b=2", text="Click <here>"))
# Output: <a href="/path?a=1&amp;b=2">Click &lt;here&gt;</a>
```

--------------------------------

### __html__ Protocol for Custom Classes in MarkupSafe

Source: https://context7.com/pallets/markupsafe/llms.txt

Classes can implement the __html__() method to provide a safe HTML representation. When objects with this method are used with MarkupSafe functions, their __html__() output is used directly, preventing double-escaping. User-provided data within __html__ should still be escaped.

```python
from markupsafe import Markup, escape

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def __html__(self):
        # IMPORTANT: escape user-provided name to prevent XSS
        return f'<a href="/user/{self.id}">{escape(self.name)}</a>'

# User objects are automatically rendered as safe HTML
user = User(42, "John <Script> Doe")
print(escape(user))
# Output: <a href="/user/42">John &lt;Script&gt; Doe</a>

# Works with Markup constructor too
print(Markup(user))
# Output: <a href="/user/42">John &lt;Script&gt; Doe</a>

# Image class example
class Image:
    def __init__(self, url, alt=""):
        self.url = url
        self.alt = alt

    def __html__(self):
        return f'<img src="{escape(self.url)}" alt="{escape(self.alt)}">' # Ensure attributes are escaped

img = Image("/static/logo.png", "Company Logo")
print(Markup("<div>{}</div>").format(img))
# Output: <div><img src="/static/logo.png" alt="Company Logo"></div>
```

--------------------------------

### markupsafe.Markup Class

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

Represents an HTML-safe string. Instances are ready for direct insertion into HTML or XML documents. Subclasses string and escapes arguments to its methods.

```APIDOC
## class markupsafe.Markup(object='', encoding=None, errors='strict')

### Description
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 [`escape()`](#markupsafe.escape) class method instead. 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. This is a subclass of [`str`](https://docs.python.org/3/library/stdtypes.html#str). It has the same methods, but escapes their arguments and returns a `Markup` instance.

### Parameters
* **object** (t.Any)
* **encoding** (str | None)
* **errors** (str)

### Return type
te.Self

### Methods
#### unescape()
Convert escaped markup back into a text string. This replaces HTML entities with the characters they represent.

* **Return type**
[str](https://docs.python.org/3/library/stdtypes.html#str)

#### striptags()
[`unescape()`](#markupsafe.Markup.unescape) the markup, remove tags, and normalize whitespace to single spaces.

* **Return type**
[str](https://docs.python.org/3/library/stdtypes.html#str)

#### classmethod escape(s,)
Escape a string. Calls [`escape()`](#markupsafe.escape) and ensures that for subclasses the correct type is returned.

* **Parameters**
  **s** (t.Any)
* **Return type**
te.Self
```

--------------------------------

### Escape Text for HTML/XML with MarkupSafe (Python)

Source: https://github.com/pallets/markupsafe/blob/main/docs/index.md

Demonstrates how to use the `escape()` function from MarkupSafe to sanitize strings for safe inclusion in HTML or XML. The `escape()` function replaces special characters with their corresponding HTML entities. It returns a `Markup` object, which ensures that subsequent operations also maintain the escaped state, preventing double-escaping and ensuring the final output is safe.

```python
from markupsafe import escape

hello = escape("<em>Hello</em>")
print(hello)
# Output: Markup('&lt;em&gt;Hello&lt;/em&gt;')

print(escape(hello))
# Output: Markup('&lt;em&gt;Hello&lt;/em&gt;')

print(hello + " <strong>World</strong>")
# Output: Markup('&lt;em&gt;Hello&lt;/em&gt; &lt;strong&gt;World&lt;/strong&gt;')
```

--------------------------------

### Escape HTML content with escape()

Source: https://context7.com/pallets/markupsafe/llms.txt

Demonstrates how to sanitize untrusted input using the escape function, which converts special characters to HTML entities and respects the __html__ protocol.

```python
from markupsafe import escape

user_input = "<script>alert('XSS')</script>"
safe_output = escape(user_input)
print(safe_output)

print(escape(42))

class SafeLink:
    def __html__(self):
        return '<a href="/home">Home</a>'

link = SafeLink()
print(escape(link))
```

--------------------------------

### Markup String Methods Preserve Safety in Python

Source: https://context7.com/pallets/markupsafe/llms.txt

Explains how standard Python string methods, when called on `Markup` objects, return `Markup` instances, thus preserving the safety of the HTML. This includes methods like `split()`, `upper()`, `replace()`, and `strip()`, ensuring that operations on safe HTML strings remain safe.

```python
from markupsafe import Markup

html = Markup("<p>Hello, World!</p>")

# split() returns list of Markup
parts = html.split(",")
print(parts)
# Output: [Markup('<p>Hello'), Markup(' World!</p>')]
print(type(parts[0]))
# Output: <class 'markupsafe.Markup'>

# Case transformation
print(html.upper())
# Output: <P>HELLO, WORLD!</P>
print(html.lower())
# Output: <p>hello, world!</p>
print(html.title())
# Output: <P>Hello, World!</P>

# replace() escapes the replacement string
template = Markup("<div>PLACEHOLDER</div>")
result = template.replace("PLACEHOLDER", "<user input>")
print(result)
# Output: <div>&lt;user input&gt;</div>

# strip methods work normally
padded = Markup("  <p>content</p>  ")
print(padded.strip())
# Output: <p>content</p>

# Slicing preserves Markup type
print(html[3:10])
# Output: >Hello,
print(type(html[3:10]))
# Output: <class 'markupsafe.Markup'>
```

--------------------------------

### Safely Join Strings with Markup.join() in Python

Source: https://context7.com/pallets/markupsafe/llms.txt

Illustrates the use of the `Markup.join()` method in Python to concatenate an iterable of strings using a `Markup` separator. This method ensures that each element is safely escaped, preventing XSS vulnerabilities when building HTML structures like navigation menus or lists.

```python
from markupsafe import Markup

# Join list items with separator, escaping each item
items = ["Home", "About <us>", "Contact & Info"]
nav = Markup(" | ").join(items)
print(nav)
# Output: Home | About &lt;us&gt; | Contact &amp; Info

# Build HTML lists safely
list_items = ["<script>", "Normal Item", "Item & More"]
html_list = Markup("<li>") + Markup("</li><li>").join(list_items) + Markup("</li>")
print(Markup("<ul>") + html_list + Markup("</ul>"))
# Output: <ul><li>&lt;script&gt;</li><li>Normal Item</li><li>Item &amp; More</li></ul>

# Empty separator concatenates safely
parts = ["<b>", "text", "</b>"]
print(Markup("").join(parts))
# Output: &lt;b&gt;text&lt;/b&gt;
```

--------------------------------

### markupsafe.soft_str

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

Converts an object to a string, preserving Markup strings to avoid double-escaping.

```APIDOC
## markupsafe.soft_str(s,)

### Description
Convert an object to a string if it isn’t already. This preserves a [`Markup`](#markupsafe.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.

### Parameters
* **s** (Any) - The object to convert to a string.

### Returns
A string representation of the object, preserving Markup status.

### Return type
str
```

--------------------------------

### Use Markup class for safe HTML strings

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

The Markup class wraps strings to mark them as safe for HTML insertion. It supports string formatting and concatenation while automatically escaping arguments.

```python
from markupsafe import Markup
# Marking text as safe
print(Markup("Hello, <em>World</em>!"))
# Formatting with Markup
print(Markup("<em>%s</em>") % ("foo & bar",))
```

--------------------------------

### Markup Class

Source: https://context7.com/pallets/markupsafe/llms.txt

The `Markup` class represents text that is safe for HTML/XML output. Its constructor marks text as safe without escaping, while string operations automatically escape concatenated or formatted values.

```APIDOC
## Markup Class

The `Markup` class is a `str` subclass that represents text safe for HTML/XML output. It wraps text to mark it safe without escaping when using the constructor directly. Use `Markup.escape()` to escape text. All string methods return `Markup` instances and escape their arguments automatically.

```python
from markupsafe import Markup

# Constructor marks text as safe WITHOUT escaping
trusted_html = Markup("<strong>Bold</strong>")
print(trusted_html)
# Output: <strong>Bold</strong>

# Use escape() class method to escape text
untrusted = Markup.escape("<script>bad</script>")
print(untrusted)
# Output: &lt;script&gt;bad&lt;/script&gt;

# String concatenation automatically escapes the added text
safe_text = Markup("<em>Hello</em> ")
result = safe_text + "<script>alert('xss')</script>"
print(result)
# Output: <em>Hello</em> &lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;

# Multiplication works as expected
repeated = Markup("<br>") * 3
print(repeated)
# Output: <br><br><br>

# All str methods return Markup and preserve safety
html = Markup("<p>hello world</p>")
print(html.upper())
# Output: <P>HELLO WORLD</P>
print(html.replace("world", "universe"))
# Output: <p>hello universe</p>
```
```

--------------------------------

### Handle optional values with escape_silent

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

The escape_silent function behaves like escape but treats None as an empty string instead of the literal string 'None'.

```python
from markupsafe import escape_silent
print(escape_silent(None))
```

--------------------------------

### markupsafe.escape_silent

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

Similar to `escape()`, but treats `None` input as an empty string, preventing 'None' from being rendered in HTML.

```APIDOC
## markupsafe.escape_silent(s,)

### Description
Like [`escape()`](#markupsafe.escape) but treats `None` as the empty string. Useful with optional values, as otherwise you get the string `'None'` when the value is `None`.

### Parameters
* **s** (Any | None) - An object to be converted to a string and escaped, or None.

### Returns
A [`Markup`](#markupsafe.Markup) string with the escaped text, or an empty Markup string if input is None.

### Return type
Markup
```

--------------------------------

### Unescape and strip tags from Markup objects

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

Markup objects provide methods to revert HTML entities to characters or remove HTML tags entirely while normalizing whitespace.

```python
from markupsafe import Markup
m = Markup("Main &raquo; <em>About</em>")
print(m.unescape())
print(m.striptags())
```

--------------------------------

### Convert objects to strings with soft_str

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

The soft_str function converts an object to a string while preserving the safety status of existing Markup objects to prevent double-escaping.

```python
from markupsafe import soft_str, escape
value = escape("<User 1>")
print(soft_str(value))
```

--------------------------------

### escape() Function

Source: https://context7.com/pallets/markupsafe/llms.txt

The `escape()` function converts special HTML characters to their safe equivalents and returns a `Markup` object. It handles various input types and respects objects with an `__html__` method.

```APIDOC
## escape() Function

The `escape()` function replaces HTML special characters (`&`, `<`, `>`, `'`, `"`) with their HTML-safe equivalents, returning a `Markup` object. If the input object has an `__html__` method, that method is called instead and its output is assumed to be already safe.

```python
from markupsafe import escape

# Escape potentially dangerous user input
user_input = "<script>alert('XSS')</script>"
safe_output = escape(user_input)
print(safe_output)
# Output: &lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;

# Numbers and other types are converted to strings and escaped
print(escape(42))
# Output: 42

# Objects with __html__ method return their safe representation
class SafeLink:
    def __html__(self):
        return '<a href="/home">Home</a>'

link = SafeLink()
print(escape(link))
# Output: <a href="/home">Home</a>

# Already escaped Markup strings are not double-escaped
already_safe = escape("<em>Hello</em>")
print(escape(already_safe))
# Output: &lt;em&gt;Hello&lt;/em&gt;
```
```

--------------------------------

### Markup.striptags() Method

Source: https://context7.com/pallets/markupsafe/llms.txt

The `striptags()` method removes all HTML tags and comments from a `Markup` string, unescapes HTML entities, and normalizes whitespace. It returns a plain string suitable for text-only display.

```APIDOC
## Markup.striptags() Method

The `striptags()` method unescapes HTML entities, removes all HTML tags (including comments), and normalizes whitespace to single spaces. Returns a plain string suitable for display as text-only content.

```python
from markupsafe import Markup

# Remove HTML tags and normalize whitespace
html_content = Markup("Main &raquo;\t<em>About</em>")
plain = html_content.striptags()
print(plain)
# Output: Main » About

# Complex HTML is stripped cleanly
complex_html = Markup("""
    <div class="header">
        <h1>Welcome</h1>
        <!-- Navigation comment -->
        <nav><a href="/">Home</a> | <a href="/about">About</a></nav>
    </div>
""")
print(complex_html.striptags())
# Output: Welcome Home | About

# Useful for generating plain text previews
article = Markup("<p><strong>Breaking:</strong> Something &amp; something else happened!</p>")
preview = article.striptags()
print(preview)
# Output: Breaking: Something & something else happened!
```
```

--------------------------------

### escape_silent() Function in MarkupSafe

Source: https://context7.com/pallets/markupsafe/llms.txt

The escape_silent() function is similar to escape() but treats None values as empty strings. It's useful for optional values in templates. It takes a value as input and returns a Markup object with HTML special characters escaped.

```python
from markupsafe import escape, escape_silent

# Regular escape converts None to string "None"
print(escape(None))
# Output: None

# escape_silent returns empty Markup for None
print(escape_silent(None))
# Output: (empty string)

# Useful with optional values
def render_user_bio(bio):
    return Markup("<p>Bio: {}</p>").format(escape_silent(bio))

print(render_user_bio("Hello <world>"))
# Output: <p>Bio: Hello &lt;world&gt;</p>

print(render_user_bio(None))
# Output: <p>Bio: </p>

# Works normally for non-None values
print(escape_silent("<script>"))
# Output: &lt;script&gt;
```

--------------------------------

### Markup.unescape() Method

Source: https://context7.com/pallets/markupsafe/llms.txt

The `unescape()` method converts HTML entities back into their original characters, returning a plain string. This is useful for extracting readable text from escaped HTML.

```APIDOC
## Markup.unescape() Method

The `unescape()` method converts HTML entities back to their original characters, returning a plain string. This is useful when you need to extract readable text from escaped HTML content.

```python
from markupsafe import Markup

# Unescape HTML entities back to characters
escaped = Markup("Main &raquo; &lt;em&gt;About&lt;/em&gt;")
plain_text = escaped.unescape()
print(plain_text)
# Output: Main » <em>About</em>

# Common HTML entities are converted
entities = Markup("&amp; &lt; &gt; &quot; &#39; &copy;")
print(entities.unescape())
# Output: & < > " ' ©

# Useful for extracting text content
user_display = Markup("Hello &amp; Welcome!")
print(user_display.unescape())
# Output: Hello & Welcome!
```
```

--------------------------------

### markupsafe.escape

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

Escapes special characters in a string to make it safe for HTML display. If an object has an `__html__` method, it is called and the result is treated as safe.

```APIDOC
## markupsafe.escape(s)

### Description
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.

### Parameters
* **s** (Any) - An object to be converted to a string and escaped.

### Returns
A [`Markup`](#markupsafe.Markup) string with the escaped text.

### Return type
Markup
```

--------------------------------

### soft_str() Function in MarkupSafe

Source: https://context7.com/pallets/markupsafe/llms.txt

The soft_str() function converts objects to strings only if they are not already strings, preserving Markup instances to prevent double-escaping. It takes an object as input and returns its string representation, or the object itself if it's already a string or Markup.

```python
from markupsafe import escape, soft_str, Markup

# Problem: str() on Markup loses the safety marker
safe_value = escape("<User 1>")
print(safe_value)
# Output: &lt;User 1&gt;

# Using str() causes double-escaping
print(escape(str(safe_value)))
# Output: &amp;lt;User 1&amp;gt;

# soft_str preserves Markup type, preventing double-escape
print(escape(soft_str(safe_value)))
# Output: &lt;User 1&gt;

# Non-string objects are converted to strings
print(soft_str(42))
# Output: 42

print(soft_str(["a", "b"]))
# Output: ['a', 'b']

# Already a string? Returns as-is
plain = "hello"
print(soft_str(plain) is plain)
# Output: True
```

--------------------------------

### Escape HTML characters with markupsafe.escape

Source: https://github.com/pallets/markupsafe/blob/main/docs/escaping.md

The escape function converts special characters like &, <, >, ', and " into HTML-safe sequences. It returns a Markup object and supports objects with an __html__ method.

```python
from markupsafe import escape
print(escape('<script>alert(1)</script>'))
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.