mwparserfromhell

https://mwparserfromhell.readthedocs.io/en/latest/
Admin
mwparserfromhell is an easy-to-use and outrageously powerful Python package for parsing MediaWiki...
Tokens:57,971
Snippets:276
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install and verify development version

Source: https://mwparserfromhell.readthedocs.io/en/latest/_sources/index.rst.txt

Commands to clone the repository, sync dependencies using uv, and verify the installation version.

```bash
git clone https://github.com/earwig/mwparserfromhell.git
cd mwparserfromhell
uv sync
uv run python -c 'import mwparserfromhell; print(mwparserfromhell.__version__)'
```

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

### Handle invalid tag start

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Attempts to parse an implicitly closing single tag, falling back to text emission if parsing fails.

```python
def _handle_invalid_tag_start(self):
    """Handle the (possible) start of an implicitly closing single tag."""
    reset = self._head + 1
    self._head += 2
    try:
        assert (this := self._read()) is not END
        if not is_single_only(self.tag_splitter.split(this)[0]):
            raise BadRoute()
        tag = self._really_parse_tag()
    except BadRoute:
        self._head = reset
        self._emit_text("</")
    else:
        tag[0].invalid = True  # Set flag of TagOpenOpen
        self._emit_all(tag)
```

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

### Manage attribute quotes and padding properties

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/extras/attribute.html

Properties for configuring attribute quote styles and spacing around the equal sign and attribute start.

```python
@property
def quotes(self) -> str | None:
    """How to enclose the attribute value. ``"``, ``'``, or ``None``."""
    return self._quotes

@quotes.setter
def quotes(self, value: Any) -> None:
    value = self.coerce_quotes(value)
    if not value and self._value_needs_quotes(self.value):
        raise ValueError("attribute value requires quotes")
    self._quotes = value

@property
def pad_first(self) -> str:
    """Spacing to insert right before the attribute."""
    return self._pad_first

@pad_first.setter
def pad_first(self, value: str) -> None:
    self._set_padding("_pad_first", value)

@property
def pad_before_eq(self) -> str:
    """Spacing to insert right before the equal sign."""
    return self._pad_before_eq

@pad_before_eq.setter
def pad_before_eq(self, value: str) -> None:
    self._set_padding("_pad_before_eq", value)

@property
def pad_after_eq(self) -> str:
    """Spacing to insert right after the equal sign."""
    return self._pad_after_eq

@pad_after_eq.setter
def pad_after_eq(self, value: str) -> None:
    self._set_padding("_pad_after_eq", value)
```

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

### Handle HTML comments

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes tokens starting with CommentStart until a CommentEnd is encountered.

```python
@_add_handler(tokens.CommentStart)
def _handle_comment(self, token):
    """Handle a case where an HTML comment is at the head of the tokens."""
    self._push()
    while self._tokens:
        token = self._tokens.pop()
        if isinstance(token, tokens.CommentEnd):
            contents = self._pop()
            return Comment(contents)
        self._write(self._handle_token(token))
    raise ParserError("_handle_comment() missed a close token")
```

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

### Tokenize method implementation

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

The primary entry point for converting a wikicode string into a list of tokens.

```python
    def tokenize(self, text: str, context=0, skip_style_tags=False):
        """Build a list of tokens from a string of wikicode and return it."""
        split = self.regex.split(text)
        self._text = [segment for segment in split if segment]
        self._head = self._global = self._depth = 0
        self._bad_routes = set()
        self._skip_style_tags = skip_style_tags

        try:
            result = self._parse(context)
        except BadRoute as exc:  # pragma: no cover (untestable/exceptional case)
            raise ParserError("Python tokenizer exited with BadRoute") from exc
        if self._stacks:  # pragma: no cover (untestable/exceptional case)
            err = "Python tokenizer exited with non-empty token stack"
            raise ParserError(err)
        return result
```

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

### get(name)

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/tag.html

Retrieves an attribute object by its name.

```APIDOC
## get(name)

### Description
Get the attribute with the given name. Returns an Attribute instance or raises ValueError if no attribute is found.

### Parameters
- **name** (str | Attribute | Wikicode) - Required - The name of the attribute to retrieve.
```

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

### Define Sentinel Enum

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Enumeration for tokenizer start and end markers.

```python
class Sentinel(Enum):
    START = 0
    END = 1


START = Sentinel.START
END = Sentinel.END
```

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

### Demonstrate SmartList sublist synchronization

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/smart_list/smart_list.html

Shows how modifications to a sublist created via slicing are reflected in the parent SmartList and vice-versa.

```python
>>> parent = SmartList([0, 1, 2, 3])
>>> parent
[0, 1, 2, 3]
>>> child = parent[2:]
>>> child
[2, 3]
>>> child.append(4)
>>> child
[2, 3, 4]
>>> parent
[0, 1, 2, 3, 4]
```

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

### Handle HTML Entity Tokens

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes HTMLEntityStart tokens to construct an HTMLEntity node.

```python
@_add_handler(tokens.HTMLEntityStart)
def _handle_entity(self, token):
    """Handle a case where an HTML entity is at the head of the tokens."""
    token = self._tokens.pop()
    if isinstance(token, tokens.HTMLEntityNumeric):
        token = self._tokens.pop()
        if isinstance(token, tokens.HTMLEntityHex):
            text = self._tokens.pop()
            self._tokens.pop()  # Remove HTMLEntityEnd
            return HTMLEntity(
                text.text, named=False, hexadecimal=True, hex_char=token.char
            )
        self._tokens.pop()  # Remove HTMLEntityEnd
        return HTMLEntity(token.text, named=False, hexadecimal=False)
    self._tokens.pop()  # Remove HTMLEntityEnd
    return HTMLEntity(token.text, named=True, hexadecimal=False)
```

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

### get(index)

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/wikicode.html

Retrieves the node at the specified index within the list of nodes.

```APIDOC
## get(index)

### Description
Returns the node at the specified index within the list of nodes.

### Parameters
- **index** (int or slice) - Required - The index or slice of the node(s) to retrieve.
```

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

### Build Wikicode object

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Main entry point to convert a list of tokens into a Wikicode object.

```python
def build(self, tokenlist):
    """Build a Wikicode object from a list tokens and return it."""
    self._tokens = tokenlist
    self._tokens.reverse()
    self._push()
    while self._tokens:
        node = self._handle_token(self._tokens.pop())
        self._write(node)
    return self._pop()
```

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

### mwparserfromhell.parser.builder.Builder.build

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.parser.html

Builds a Wikicode object containing a node tree from a provided list of tokens.

```APIDOC
## Builder.build(tokenlist)

### Description
Builds a tree of nodes out of a sequence of tokens. The provided list of tokens is exhausted during the parsing process.

### Parameters
- **tokenlist** (list) - Required - A list of Token objects to be parsed.

### Returns
- **Wikicode** - A Wikicode object containing the resulting node tree.
```

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

### Handle horizontal rules

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Parses wiki-style horizontal rules starting with four or more dashes.

```python
    def _handle_hr(self):
        """Handle a wiki-style horizontal rule (``----``) in the string."""
        length = 4
        self._head += 3
        while self._read(1) == "-":
            length += 1
            self._head += 1
        self._emit(tokens.TagOpenOpen(wiki_markup="-" * length))
        self._emit_text("hr")
        self._emit(tokens.TagCloseSelfclose())
```

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

### List Proxy Properties and Rendering

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/smart_list/list_proxy.html

Properties for managing slice boundaries and rendering the proxy content.

```python
    @property
    def _start(self):
        """The starting index of this list, inclusive."""
        return self._sliceinfo[0]

    @property
    def _stop(self):
        """The ending index of this list, exclusive."""
        if self._sliceinfo[1] is None:
            return len(self._parent)
        return self._sliceinfo[1]

    @property
    def _step(self):
        """The number to increase the index by between items."""
        return self._sliceinfo[2]

    def _render(self):
        """Return the actual list from the stored start/stop/step."""
        return list(self._parent)[self._start : self._stop : self._step]
```

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

### Retrieve an attribute from a Tag

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/tag.html

Use the get method to fetch an Attribute instance by name. It raises a ValueError if the attribute is not found.

```python
    def get(self, name: str | Attribute | Wikicode) -> Attribute:
        """Get the attribute with the given *name*.

        The returned object is a :class:`.Attribute` instance. Raises
        :exc:`ValueError` if no attribute has this name. Since multiple
        attributes can have the same name, we'll return the last match, since
        all but the last are ignored by the MediaWiki parser.
        """
        for attr in reversed(self.attributes):
            if attr.name == name.strip():
                return attr
        raise ValueError(name)
```

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

### Handle list markers

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Processes wiki-style list markers like #, *, ;, and :.

```python
    def _handle_list_marker(self):
        """Handle a list marker at the head (``#``, ``*``, ``;``, ``:``)."""
        markup = self._read()
        assert markup is not END
        if markup == ";":
            self._context |= contexts.DL_TERM
        self._emit(tokens.TagOpenOpen(wiki_markup=markup))
        self._emit_text(get_html_tag(markup))
        self._emit(tokens.TagCloseSelfclose())
```

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

### Tokenizer.tokenize(text, context=0, skip_style_tags=False)

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.parser.html

Builds a list of tokens from a string of wikicode and returns it.

```APIDOC
## Tokenizer.tokenize

### Description
Builds a list of tokens from a string of wikicode and returns it.

### Parameters
- **text** (str) - Required - The string of wikicode to tokenize.
- **context** (int) - Optional - The starting context for the tokenizer.
- **skip_style_tags** (bool) - Optional - Whether to ignore style tags during tokenization.
```

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

### Run test suite with uv

Source: https://mwparserfromhell.readthedocs.io/en/latest/_sources/index.rst.txt

Executes the test suite using pytest, ensuring the extension module is reinstalled for accurate testing.

```bash
uv run --reinstall-package mwparserfromhell pytest
```

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

### Set Item Shortcut

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/template.html

Provides dictionary-like access to add parameters.

```python
    def __setitem__(self, name: Any, value: Any) -> Parameter:
        return self.add(name, value)
```

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

### Handle Heading Tokens

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes HeadingStart tokens to construct a Heading node.

```python
@_add_handler(tokens.HeadingStart)
def _handle_heading(self, token):
    """Handle a case where a heading is at the head of the tokens."""
    level = token.level
    self._push()
    while self._tokens:
        token = self._tokens.pop()
        if isinstance(token, tokens.HeadingEnd):
            title = self._pop()
            return Heading(title, level)
        self._write(self._handle_token(token))
    raise ParserError("_handle_heading() missed a close token")
```

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

### mwparserfromhell.parser.contexts.describe

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.parser.html

Returns a descriptive string for a given context value, useful for debugging parsing states.

```APIDOC
## contexts.describe(context)

### Description
Returns a string describing the given context value, for debugging purposes.

### Parameters
- **context** (int) - Required - The context flag value to describe.

### Returns
- **str** - A string representation of the context.
```

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

### Tokenizer Logic Implementation

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

This snippet contains the core conditional logic for identifying and parsing MediaWiki syntax tokens during the tokenization process.

```python
            elif this == nxt == "]" and self._context & contexts.WIKILINK:
                return self._handle_wikilink_end()
            elif this == "[":
                self._parse_external_link(True)
            elif this == ":" and self._read(-1) not in self.MARKERS:
                self._parse_external_link(False)
            elif this == "]" and self._context & contexts.EXT_LINK_TITLE:
                return self._pop()
            elif (
                this == "="
                and not self._global & contexts.GL_HEADING
                and not self._context & contexts.TEMPLATE
            ):
                if self._read(-1) in ("\n", START):
                    self._parse_heading()
                else:
                    self._emit_text("=")
            elif this == "=" and self._context & contexts.HEADING:
                return self._handle_heading_end()
            elif this == "\n" and self._context & contexts.HEADING:
                self._fail_route()
            elif this == "&":
                self._parse_entity()
            elif this == "<" and nxt == "!":
                if self._read(2) == self._read(3) == "-":
                    self._parse_comment()
                else:
                    self._emit_text(this)
            elif this == "<" and nxt == "/" and self._read(2) is not END:
                if self._context & contexts.TAG_BODY:
                    self._handle_tag_open_close()
                else:
                    self._handle_invalid_tag_start()
            elif this == "<" and not self._context & contexts.TAG_CLOSE:
                if self._can_recurse():
                    self._parse_tag()
                else:
                    self._emit_text("<")
            elif this == ">" and self._context & contexts.TAG_CLOSE:
                return self._handle_tag_close_close()
            elif this == nxt == "'" and not self._skip_style_tags:
                result = self._parse_style()
                if result is not None:
                    return result
            elif self._read(-1) in ("\n", START) and this in ("#", "*", ";", ":"):
                self._handle_list()
            elif self._read(-1) in ("\n", START) and (
                this == nxt == self._read(2) == self._read(3) == "-"
            ):
                self._handle_hr()
            elif this in ("\n", ":") and self._context & contexts.DL_TERM:
                self._handle_dl_term()
                if this == "\n":
                    # Kill potential table contexts
                    self._context &= ~contexts.TABLE_CELL_LINE_CONTEXTS
            # Start of table parsing
            elif (
                this == "{"
                and nxt == "|"
                and (
                    self._read(-1) in ("\n", START)
                    or (
                        self._read(-2) in ("\n", START)
                        and cast(str, self._read(-1)).isspace()
                    )
                )
            ):
                if self._can_recurse():
                    self._parse_table()
                else:
                    self._emit_text("{")
            elif self._context & contexts.TABLE_OPEN:
                if this == nxt == "|" and self._context & contexts.TABLE_TD_LINE:
                    if self._context & contexts.TABLE_CELL_OPEN:
                        return self._handle_table_cell_end()
                    self._handle_table_cell("||", "td", contexts.TABLE_TD_LINE)
                elif this == nxt == "|" and self._context & contexts.TABLE_TH_LINE:
                    if self._context & contexts.TABLE_CELL_OPEN:
                        return self._handle_table_cell_end()
                    self._handle_table_cell("||", "th", contexts.TABLE_TH_LINE)
                elif this == nxt == "!" and self._context & contexts.TABLE_TH_LINE:
                    if self._context & contexts.TABLE_CELL_OPEN:
                        return self._handle_table_cell_end()
                    self._handle_table_cell("!!", "th", contexts.TABLE_TH_LINE)
                elif this == "|" and self._context & contexts.TABLE_CELL_STYLE:
                    return self._handle_table_cell_end(reset_for_style=True)
                # on newline, clear out cell line contexts
                elif this == "\n" and self._context & contexts.TABLE_CELL_LINE_CONTEXTS:
                    self._context &= ~contexts.TABLE_CELL_LINE_CONTEXTS
                    self._emit_text(this)
                elif self._read(-1) in ("\n", START) or (
                    self._read(-2) in ("\n", START)
                    and cast(str, self._read(-1)).isspace()
                ):
                    if this == "|" and nxt == "}":
                        if self._context & contexts.TABLE_CELL_OPEN:
                            return self._handle_table_cell_end()
                        if self._context & contexts.TABLE_ROW_OPEN:
```

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

### Implement Builder class

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

The Builder class manages the transformation of tokens into a Wikicode node tree using internal stacks.

```python
class Builder:
    """Builds a tree of nodes out of a sequence of tokens.

    To use, pass a list of :class:`.Token`\ s to the :meth:`build` method. The
    list will be exhausted as it is parsed and a :class:`.Wikicode` object
    containing the node tree will be returned.
    """

    def __init__(self):
        self._tokens = []
        self._stacks = []

    def _push(self):
        """Push a new node list onto the stack."""
        self._stacks.append([])

    def _pop(self):
        """Pop the current node list off of the stack.

        The raw node list is wrapped in a :class:`.SmartList` and then in a
        :class:`.Wikicode` object.
        """
        return Wikicode(SmartList(self._stacks.pop()))

    def _write(self, item):
        """Append a node to the current node list."""
        self._stacks[-1].append(item)

    def _handle_parameter(self, default):
        """Handle a case where a parameter is at the head of the tokens.

        *default* is the value to use if no parameter name is defined.
        """
        key = None
        showkey = False
        self._push()
        while self._tokens:
            token = self._tokens.pop()
            if isinstance(token, tokens.TemplateParamEquals):
                key = self._pop()
                showkey = True
                self._push()
            elif isinstance(
                token, (tokens.TemplateParamSeparator, tokens.TemplateClose)
            ):
                self._tokens.append(token)
                value = self._pop()
                if key is None:
                    key = Wikicode(SmartList([Text(str(default))]))
                return Parameter(key, value, showkey)
            else:
                self._write(self._handle_token(token))
        raise ParserError("_handle_parameter() missed a close token")
```

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

### Handle Template Parameters

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Methods for managing template parameter keys and values during tokenization.

```python
def _handle_template_param(self):
        """Handle a template parameter at the head of the string."""
        if self._context & contexts.TEMPLATE_NAME:
            if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
                self._fail_route()
            self._context ^= contexts.TEMPLATE_NAME
        elif self._context & contexts.TEMPLATE_PARAM_VALUE:
            self._context ^= contexts.TEMPLATE_PARAM_VALUE
        else:
            self._emit_all(self._pop())
        self._context |= contexts.TEMPLATE_PARAM_KEY
        self._emit(tokens.TemplateParamSeparator())
        self._push(self._context)
```

```python
def _handle_template_param_value(self):
        """Handle a template parameter's value at the head of the string."""
        self._emit_all(self._pop())
        self._context ^= contexts.TEMPLATE_PARAM_KEY
        self._context |= contexts.TEMPLATE_PARAM_VALUE
        self._emit(tokens.TemplateParamEquals())
```

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

### Parse Wikicode

Source: https://mwparserfromhell.readthedocs.io/en/latest/_sources/usage.rst.txt

Initialize a Wikicode object from raw text.

```python
>>> import mwparserfromhell
>>> wikicode = mwparserfromhell.parse(text)
```

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

### insert_methods

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.html

Methods for inserting content into the wikicode object.

```APIDOC
## insert(index, value), insert_after(obj, value, recursive=True), insert_before(obj, value, recursive=True)

### Description
Methods to insert new content (value) at a specific index or relative to an existing object (obj).

### Parameters
- **index** (int) - Required (for insert) - Position to insert.
- **obj** (Node | Wikicode | str) - Required (for insert_after/before) - The reference object.
- **value** (Any) - Required - The content to insert.
- **recursive** (bool) - Optional - Whether to search for the reference object recursively.
```

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

### Handle Template Tokens

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes TemplateOpen tokens to construct a Template node.

```python
@_add_handler(tokens.TemplateOpen)
def _handle_template(self, token):
    """Handle a case where a template is at the head of the tokens."""
    name = None
    params = []
    default = 1
    self._push()
    while self._tokens:
        token = self._tokens.pop()
        if isinstance(token, tokens.TemplateParamSeparator):
            if not params:
                name = self._pop()
            param = self._handle_parameter(default)
            params.append(param)
            if not param.showkey:
                default += 1
        elif isinstance(token, tokens.TemplateClose):
            if not params:
                name = self._pop()
            assert name is not None
            return Template(name, params)
        else:
            self._write(self._handle_token(token))
    raise ParserError("_handle_template() missed a close token")
```

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

### String mixin methods implementation

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/string_mixin.html

These methods implement standard string behaviors by casting the instance to a string and calling the corresponding method.

```python
[docs]
    @inheritdoc
    def startswith(
        self,
        prefix: str | tuple[str, ...],
        start: SupportsIndex | None = None,
        end: SupportsIndex | None = None,
    ) -> bool:
        return str(self).startswith(prefix, start, end)
```

```python
[docs]
    @inheritdoc
    def strip(self, chars: str | None = None) -> str:
        return str(self).strip(chars)
```

```python
[docs]
    @inheritdoc
    def swapcase(self) -> str:
        return str(self).swapcase()
```

```python
[docs]
    @inheritdoc
    def title(self) -> str:
        return str(self).title()
```

```python
[docs]
    @inheritdoc
    def translate(self, *args: Any) -> str:
        return str(self).translate(*args)
```

```python
[docs]
    @inheritdoc
    def upper(self) -> str:
        return str(self).upper()
```

```python
[docs]
    @inheritdoc
    def zfill(self, width: int) -> str:
        return str(self).zfill(width)
```

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

### StringMixIn Method Implementations

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/string_mixin.html

A collection of methods that delegate string operations to the object's string representation.

```python
@inheritdoc
def expandtabs(self, tabsize: int = 8) -> str:
    return str(self).expandtabs(tabsize)
```

```python
@inheritdoc
def find(
    self,
    sub: str | StringMixIn,
    start: SupportsIndex | None = None,
    end: SupportsIndex | None = None,
) -> int:
    if isinstance(sub, StringMixIn):
        sub = str(sub)
    return str(self).find(sub, start, end)
```

```python
@inheritdoc
def format(self, /, *args: Any, **kwds: Any) -> str:
    return str(self).format(*args, **kwds)
```

```python
@inheritdoc
def format_map(self, mapping: Mapping[str, Any]) -> str:
    return str(self).format_map(mapping)
```

```python
@inheritdoc
def index(
    self,
    sub: str,
    start: SupportsIndex | None = None,
    end: SupportsIndex | None = None,
) -> int:
    return str(self).index(sub, start, end)
```

```python
@inheritdoc
def isalpha(self) -> bool:
    return str(self).isalpha()
```

```python
@inheritdoc
def isalnum(self) -> bool:
    return str(self).isalnum()
```

```python
@inheritdoc
def isascii(self) -> bool:
    return str(self).isascii()
```

```python
@inheritdoc
def isdecimal(self) -> bool:
    return str(self).isdecimal()
```

```python
@inheritdoc
def isdigit(self) -> bool:
    return str(self).isdigit()
```

```python
@inheritdoc
def isidentifier(self) -> bool:
    return str(self).isidentifier()
```

```python
@inheritdoc
def islower(self) -> bool:
    return str(self).islower()
```

```python
@inheritdoc
def isnumeric(self) -> bool:
    return str(self).isnumeric()
```

```python
@inheritdoc
def isprintable(self) -> bool:
    return str(self).isprintable()
```

```python
@inheritdoc
def isspace(self) -> bool:
    return str(self).isspace()
```

```python
@inheritdoc
def istitle(self) -> bool:
    return str(self).istitle()
```

```python
@inheritdoc
def isupper(self) -> bool:
    return str(self).isupper()
```

```python
@inheritdoc
def join(self, seq: Iterable[str]) -> str:
    return str(self).join(seq)
```

```python
@inheritdoc
def ljust(self, width: int, fillchar: str = " ") -> str:
    return str(self).ljust(width, fillchar)
```

```python
@inheritdoc
def lower(self) -> str:
    return str(self).lower()
```

```python
@inheritdoc
def lstrip(self, chars: str | None = None) -> str:
    return str(self).lstrip(chars)
```

```python
maketrans = str.maketrans
```

```python
@inheritdoc
def partition(self, sep: str) -> tuple[str, str, str]:
    return str(self).partition(sep)
```

```python
@inheritdoc
def removeprefix(self, prefix: str | StringMixIn, /) -> str:
    if isinstance(prefix, StringMixIn):
        prefix = str(prefix)
    return str(self).removeprefix(prefix)
```

```python
@inheritdoc
def removesuffix(self, suffix: str | StringMixIn, /) -> str:
    if isinstance(suffix, StringMixIn):
        suffix = str(suffix)
    return str(self).removesuffix(suffix)
```

```python
@inheritdoc
def replace(
    self,
    old: str | StringMixIn,
    new: str | StringMixIn,
    /,
    count: SupportsIndex = -1,
):
    if isinstance(old, StringMixIn):
        old = str(old)
    if isinstance(new, StringMixIn):
        new = str(new)
    return str(self).replace(old, new, count)
```

```python
@inheritdoc
def rfind(
    self,
    sub: str | StringMixIn,
    start: SupportsIndex | None = None,
    end: SupportsIndex | None = None,
) -> int:
    if isinstance(sub, StringMixIn):
        sub = str(sub)
    return str(self).rfind(sub, start, end)
```

```python
@inheritdoc
def rindex(
    self,
    sub: str,
    start: SupportsIndex | None = None,
    end: SupportsIndex | None = None,
) -> int:
    return str(self).rindex(sub, start, end)
```

```python
@inheritdoc
def rjust(self, width: int, fillchar: str = " ") -> str:
    return str(self).rjust(width, fillchar)
```

```python
@inheritdoc
def rpartition(self, sep: str) -> tuple[str, str, str]:
    return str(self).rpartition(sep)
```

```python
@inheritdoc
def rstrip(self, chars: str | None = None) -> str:
    return str(self).rstrip(chars)
```

```python
@inheritdoc
def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]:
    return str(self).split(sep, maxsplit)
```

```python
@inheritdoc
def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]:
    return str(self).rsplit(sep, maxsplit)
```

```python
@inheritdoc
def splitlines(self, keepends: bool = False) -> list[str]:
    return str(self).splitlines(keepends)
```

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

### partition(sep)

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.html

Partitions the string into three parts using the given separator.

```APIDOC
## partition(sep)

### Description
Partition the string into three parts using the given separator. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it. If not found, returns a 3-tuple containing the original string and two empty strings.

### Parameters
- **sep** (str) - Required - The separator to partition by.
```

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

### Handle Template End

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Finalizes the template parsing state.

```python
def _handle_template_end(self):
        """Handle the end of a template at the head of the string."""
        if self._context & contexts.TEMPLATE_NAME:
            if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
                self._fail_route()
        elif self._context & contexts.TEMPLATE_PARAM_KEY:
            self._emit_all(self._pop())
        self._head += 1
        return self._pop()
```

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

### Parse templates and arguments

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Methods to parse template and argument structures from the wikicode.

```python
def _parse_template(self, has_content):
    """Parse a template at the head of the wikicode string."""
    reset = self._head
    context = contexts.TEMPLATE_NAME
    if has_content:
        context |= contexts.HAS_TEMPLATE
    try:
        template = self._parse(context)
    except BadRoute:
        self._head = reset
        raise
    self._emit_first(tokens.TemplateOpen())
    self._emit_all(template)
    self._emit(tokens.TemplateClose())
```

```python
def _parse_argument(self):
    """Parse an argument at the head of the wikicode string."""
    reset = self._head
    try:
        argument = self._parse(contexts.ARGUMENT_NAME)
    except BadRoute:
        self._head = reset
        raise
    self._emit_first(tokens.ArgumentOpen())
    self._emit_all(argument)
    self._emit(tokens.ArgumentClose())
```

```python
def _parse_template_or_argument(self):
    """Parse a template or argument at the head of the wikicode string."""
    self._head += 2
    braces = 2
    while self._read() == "{":
        self._head += 1
        braces += 1
    has_content = False
    self._push()
```

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

### List Proxy Public API Methods

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/smart_list/list_proxy.html

Standard list methods implemented for the proxy class.

```python
    @inheritdoc
    def append(self, item):
        self._parent.insert(self._stop, item)

    @inheritdoc
    def count(self, item):
        return self._render().count(item)

    @inheritdoc
    def index(self, item, start=None, stop=None):
        if start is not None:
            if stop is not None:
                return self._render().index(item, start, stop)
            return self._render().index(item, start)
        return self._render().index(item)

    @inheritdoc
    def extend(self, item):
        self._parent[self._stop : self._stop] = item

    @inheritdoc
    def insert(self, index, item):
        if index < 0:
            index = len(self) + index
        self._parent.insert(self._start + index, item)

    @inheritdoc
    def pop(self, index=None):
        length = len(self)
        if index is None:
            index = length - 1
        elif index < 0:
            index = length + index
        if index < 0 or index >= length:
            raise IndexError("pop index out of range")
        return self._parent.pop(self._start + index)

    @inheritdoc
    def remove(self, item):
        index = self.index(item)
        del self._parent[self._start + index]

    @inheritdoc
    def reverse(self):
        item = self._render()
        item.reverse()
        self._parent[self._start : self._stop : self._step] = item

    @inheritdoc
    def sort(self, *, key=None, reverse=None):
        item = self._render()
        kwargs = {}
        if key is not None:
            kwargs["key"] = key
        if reverse is not None:
            kwargs["reverse"] = reverse
        item.sort(**kwargs)
        self._parent[self._start : self._stop : self._step] = item
```

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

### Implement __showtree__ for Tag node

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/tag.html

This method defines how the tag node is represented in the tree structure.

```python
    def __showtree__(
        self,
        write: Callable[[str], None],
        get: Callable[[Wikicode], None],
        mark: Callable[[], None],
    ) -> None:
        write("</" if self.invalid else "<")
        get(self.tag)
        for attr in self.attributes:
            get(attr.name)
            if not attr.value:
                continue
            write("    = ")
            mark()
            get(attr.value)
        if self.self_closing:
            write(">" if self.implicit else "/>")
        else:
            write(">")
            get(self.contents)
            write("</")
            get(self.closing_tag)
            write(">")
```

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

### Handle Wikilink Tokens

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes WikilinkOpen tokens to construct a Wikilink node.

```python
@_add_handler(tokens.WikilinkOpen)
def _handle_wikilink(self, token):
    """Handle a case where a wikilink is at the head of the tokens."""
    title = None
    self._push()
    while self._tokens:
        token = self._tokens.pop()
        if isinstance(token, tokens.WikilinkSeparator):
            title = self._pop()
            self._push()
        elif isinstance(token, tokens.WikilinkClose):
            if title is not None:
                return Wikilink(title, self._pop())
            return Wikilink(self._pop())
        else:
            self._write(self._handle_token(token))
    raise ParserError("_handle_wikilink() missed a close token")
```

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

### Parse a page using the MediaWiki API

Source: https://mwparserfromhell.readthedocs.io/en/latest/_sources/integration.rst.txt

Fetches raw page content directly from the MediaWiki API using the requests library.

```python
import mwparserfromhell
import requests

API_URL = "https://en.wikipedia.org/w/api.php"

def parse(title):
    params = {
        "action": "query",
        "prop": "revisions",
        "rvprop": "content",
        "rvslots": "main",
        "rvlimit": 1,
        "titles": title,
        "format": "json",
        "formatversion": "2",
    }
    headers = {"User-Agent": "My-Bot-Name/1.0"}
    req = requests.get(API_URL, headers=headers, params=params)
    res = req.json()
    revision = res["query"]["pages"][0]["revisions"][0]
    text = revision["slots"]["main"]["content"]
    return mwparserfromhell.parse(text)
```

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

### Handle Argument Tokens

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/builder.html

Processes ArgumentOpen tokens to construct an Argument node.

```python
@_add_handler(tokens.ArgumentOpen)
def _handle_argument(self, token):
    """Handle a case where an argument is at the head of the tokens."""
    name = None
    self._push()
    while self._tokens:
        token = self._tokens.pop()
        if isinstance(token, tokens.ArgumentSeparator):
            name = self._pop()
            self._push()
        elif isinstance(token, tokens.ArgumentClose):
            if name is not None:
                return Argument(name, self._pop())
            return Argument(self._pop())
        else:
            self._write(self._handle_token(token))
    raise ParserError("_handle_argument() missed a close token")
```

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

### mwparserfromhell.parser.Parser.parse

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.parser.html

Parses the provided wikicode text and returns a Wikicode object tree.

```APIDOC
## Parser.parse(text, context=0, skip_style_tags=False)

### Description
Parses the input wikicode text into a tree of Wikicode objects. This method should not be called concurrently across threads.

### Parameters
- **text** (str) - Required - The wikicode string to be parsed.
- **context** (int) - Optional - Starting context for the parser, useful for specific node attribute parsing.
- **skip_style_tags** (bool) - Optional - If True, ignores '' and ''' style tags, treating them as plain text.

### Returns
- **Wikicode** - A tree of Wikicode objects representing the parsed input.

### Errors
- **ParserError** - Raised if an internal error occurs during the parsing process.
```

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

### matches

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.html

Performs a loose equivalency test between the wikicode object and another object.

```APIDOC
## matches(other)

### Description
Performs a loose equivalency test suitable for comparing page names or template names, normalizing whitespace and case.

### Parameters
- **other** (Node | Wikicode | str | bytes | Iterable) - Required - The object to compare against.
```

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

### Emit table tags

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Constructs and emits the tokens required for a wiki table tag.

```python
    def _emit_table_tag(
        self,
        open_open_markup,
        tag,
        style,
        padding,
        close_open_markup,
        contents,
        open_close_markup,
    ):
        """Emit a table tag."""
        self._emit(tokens.TagOpenOpen(wiki_markup=open_open_markup))
        self._emit_text(tag)
        if style:
            self._emit_all(style)
        if close_open_markup:
            self._emit(
                tokens.TagCloseOpen(wiki_markup=close_open_markup, padding=padding)
            )
        else:
            self._emit(tokens.TagCloseOpen(padding=padding))
        if contents:
            self._emit_all(contents)
        self._emit(tokens.TagOpenClose(wiki_markup=open_close_markup))
        self._emit_text(tag)
        self._emit(tokens.TagCloseClose())
```

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

### mwparserfromhell.nodes.Template

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/mwparserfromhell.nodes.html

Represents a template structure in wikicode.

```APIDOC
## class Template(name, params=None)

### Description
Represents a template in wikicode, such as {{foo}}.
```

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

### Parse a page using Pywikibot

Source: https://mwparserfromhell.readthedocs.io/en/latest/_sources/integration.rst.txt

Uses the Pywikibot library to fetch page content before parsing with mwparserfromhell.

```python
import mwparserfromhell
import pywikibot

def parse(title):
    site = pywikibot.Site()
    page = pywikibot.Page(site, title)
    text = page.get()
    return mwparserfromhell.parse(text)
```

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

### parse()

Source: https://mwparserfromhell.readthedocs.io/en/latest/api/modules.html

The primary function to parse a string of MediaWiki wikicode into a Wikicode object.

```APIDOC
## parse(text)

### Description
Parses the provided MediaWiki wikicode string and returns a `Wikicode` object.

### Parameters
- **text** (string) - Required - The raw wikicode string to be parsed.
```

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

### List Proxy Implementation Methods

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/smart_list/list_proxy.html

Internal methods for handling list operations like deletion, iteration, and arithmetic.

```python
    def __delitem__(self, key):
        if isinstance(key, slice):
            key = self._normalize_slice(key, clamp=True)
            keystart = min(self._start + key.start, self._stop)
            keystop = min(self._start + key.stop, self._stop)
            adjusted = slice(keystart, keystop, key.step)
            del self._parent[adjusted]
        else:
            length = len(self)
            if key < 0:
                key = length + key
            if key < 0 or key >= length:
                raise IndexError("list assignment index out of range")
            del self._parent[self._start + key]

    def __iter__(self):
        i = self._start
        while i < self._stop:
            yield self._parent[i]
            i += self._step

    def __reversed__(self):
        i = self._stop - 1
        while i >= self._start:
            yield self._parent[i]
            i -= self._step

    def __contains__(self, item):
        return item in self._render()

    def __add__(self, other):
        return type(self._parent)(list(self) + other)

    def __radd__(self, other):
        return type(self._parent)(other + list(self))

    def __iadd__(self, other):
        self.extend(other)
        return self

    def __mul__(self, other):
        return type(self._parent)(list(self) * other)

    def __rmul__(self, other):
        return type(self._parent)(other * list(self))

    def __imul__(self, other):
        self.extend(list(self) * (other - 1))
        return self
```

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

### Define Tokenizer Class

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Main class responsible for creating a list of tokens from a string of wikicode.

```python
class Tokenizer:
    """Creates a list of tokens from a string of wikicode."""

    USES_C = False
    MARKERS: list[str | Sentinel] = [
        "{",
        "}",
        "[",
        "]",
        "<",
        ">",
        "|",
        "=",
        "&",
        "'",
        '"',
        "#",
        "*",
        ";",
        ":",
        "/",
        "-",
        "!",
        "\n",
        START,
        END,
    ]
    URISCHEME = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+.-"
    MAX_DEPTH = 100
    regex = re.compile(r"([{}\[\]<>|=&'#*;:/\\\"\-!\n])", flags=re.IGNORECASE)
    tag_splitter = re.compile(r"([\s\"\'\\]+)")

    def __init__(self):
        self._text: list[str] = []
        self._head: int = 0
        self._stacks = []
        self._global = 0
        self._depth = 0
        self._bad_routes = set()
        self._skip_style_tags = False

    @property
    def _stack(self):
        """The current token stack."""
        return self._stacks[-1][0]

    @property
    def _context(self):
        """The current token context."""
        return self._stacks[-1][1]

    @_context.setter
    def _context(self, value):
        self._stacks[-1][1] = value

    @property
    def _textbuffer(self):
        """The current textbuffer."""
        return self._stacks[-1][2]

    @_textbuffer.setter
    def _textbuffer(self, value):
        self._stacks[-1][2] = value

    @property
    def _stack_ident(self):
        """An identifier for the current stack.

        This is based on the starting head position and context. Stacks with
        the same identifier are always parsed in the same way. This can be used
        to cache intermediate parsing info.
        """
        return self._stacks[-1][3]

    def _push(self, context=0):
        """Add a new token stack, context, and textbuffer to the list."""
        new_ident = (self._head, context)
        if new_ident in self._bad_routes:
            raise BadRoute(context)

        self._stacks.append([[], context, [], new_ident])
        self._depth += 1

    def _push_textbuffer(self):
        """Push the textbuffer onto the stack as a Text node and clear it."""
        if self._textbuffer:
            self._stack.append(tokens.Text(text="".join(self._textbuffer)))
            self._textbuffer = []
```

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

### Parser.parse(text, context=0, skip_style_tags=False)

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser.html

Parses the provided wikicode text and returns a Wikicode object tree. This method handles the two-step process of tokenization and building.

```APIDOC
## Parser.parse

### Description
Parses the input wikicode text and returns a structured tree of Wikicode objects. This method performs tokenization followed by tree building.

### Parameters
- **text** (string) - Required - The raw wikicode text to be parsed.
- **context** (int) - Optional - The starting context for the parser, useful for specific node attribute parsing.
- **skip_style_tags** (bool) - Optional - If True, style tags ('' and ''') are treated as plain text instead of being parsed.

### Returns
- **Wikicode** (object) - The resulting object tree representing the parsed wikicode.

### Errors
- **ParserError** - Raised if an internal error occurs during the parsing process.
```

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

### add(name, value, quotes, pad_first, pad_before_eq, pad_after_eq)

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/nodes/tag.html

Adds a new attribute to the tag.

```APIDOC
## add(name, value, quotes, pad_first, pad_before_eq, pad_after_eq)

### Description
Adds an attribute with the given name and value to the tag.

### Parameters
- **name** (Any) - Required - The name of the attribute.
- **value** (Any) - Optional - The value of the attribute.
- **quotes** (str | None) - Optional - The quote character to wrap the value in.
- **pad_first** (str) - Optional - Whitespace padding before the name.
- **pad_before_eq** (str) - Optional - Whitespace padding before the equal sign.
- **pad_after_eq** (str) - Optional - Whitespace padding after the equal sign.
```

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

### Handle tag closing and opening

Source: https://mwparserfromhell.readthedocs.io/en/latest/_modules/mwparserfromhell/parser/tokenizer.html

Methods for managing the lifecycle of opening and closing HTML tags.

```python
def _handle_tag_close_open(self, data, token):
    """Handle the closing of a open tag (``<foo>``)."""
    if data.context & (data.CX_ATTR_NAME | data.CX_ATTR_VALUE):
        self._push_tag_buffer(data)
    self._emit(token(padding=data.padding_buffer["first"]))
    self._head += 1
```

```python
def _handle_tag_open_close(self):
    """Handle the opening of a closing tag (``</foo>``)."""
    self._emit(tokens.TagOpenClose())
    self._push(contexts.TAG_CLOSE)
    self._head += 1
```

```python
def _handle_tag_close_close(self):
    """Handle the ending of a closing tag (``</foo>``)."""

    def strip(tok):
        return tok.text.rstrip().lower()
```
Tokens:
Raw