Changed code to support older Python versions

venv/lib/python3.11/site-packages/mcstatus/motd/simplifies.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import typing as t
+from collections.abc import Sequence
+
+from mcstatus.motd.components import Formatting, MinecraftColor, ParsedMotdComponent, WebColor
+
+_PARSED_MOTD_COMPONENTS_TYPEVAR = t.TypeVar("_PARSED_MOTD_COMPONENTS_TYPEVAR", bound="list[ParsedMotdComponent]")
+
+
+def get_unused_elements(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Get indices of all items which are unused and can be safely removed from the MOTD.
+
+    This is a wrapper method around several unused item collection methods.
+    """
+    to_remove: set[int] = set()
+
+    for simplifier in [
+        get_double_items,
+        get_double_colors,
+        get_formatting_before_color,
+        get_meaningless_resets_and_colors,
+        get_empty_text,
+        get_end_non_text,
+    ]:
+        to_remove.update(simplifier(parsed))
+
+    return to_remove
+
+
+def squash_nearby_strings(parsed: _PARSED_MOTD_COMPONENTS_TYPEVAR) -> _PARSED_MOTD_COMPONENTS_TYPEVAR:
+    """Squash duplicate strings together.
+
+    Note that this function doesn't create a copy of passed array, it modifies it.
+    This is what those typevars are for in the function signature.
+    """
+    # in order to not break indexes, we need to fill values and then remove them after the loop
+    fillers: set[int] = set()
+    for index, item in enumerate(parsed):
+        if not isinstance(item, str):
+            continue
+
+        try:
+            next_item = parsed[index + 1]
+        except IndexError:  # Last item (without any next item)
+            break
+
+        if isinstance(next_item, str):
+            parsed[index + 1] = item + next_item
+            fillers.add(index)
+
+    for already_removed, index_to_remove in enumerate(fillers):
+        parsed.pop(index_to_remove - already_removed)
+
+    return parsed
+
+
+def get_double_items(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Get indices of all doubled items that can be removed.
+
+    Removes any items that are followed by an item of the same kind (compared using ``__eq__``).
+    """
+    to_remove: set[int] = set()
+
+    for index, item in enumerate(parsed):
+        try:
+            next_item = parsed[index + 1]
+        except IndexError:  # Last item (without any next item)
+            break
+
+        if isinstance(item, (Formatting, MinecraftColor, WebColor)) and item == next_item:
+            to_remove.add(index)
+
+    return to_remove
+
+
+def get_double_colors(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Get indices of all doubled color items.
+
+    As colors (obviously) override each other, we only ever care about the last one, ignore
+    the previous ones. (for example: specifying red color, then orange, then yellow, then some text
+    will just result in yellow text)
+    """
+    to_remove: set[int] = set()
+
+    prev_color: int | None = None
+    for index, item in enumerate(parsed):
+        if isinstance(item, (MinecraftColor, WebColor)):
+            # If we found a color after another, remove the previous color
+            if prev_color is not None:
+                to_remove.add(prev_color)
+            prev_color = index
+
+        # If we find a string, that's what our color we found previously applies to,
+        # set prev_color to None, marking this color as used
+        if isinstance(item, str):
+            prev_color = None
+
+    return to_remove
+
+
+def get_formatting_before_color(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Obtain indices of all unused formatting items before colors.
+
+    Colors override any formatting before them, meaning we only ever care about the color, and can
+    ignore all formatting before it. (For example: specifying bold formatting, then italic, then yellow,
+    will just result in yellow text.)
+    """
+    to_remove: set[int] = set()
+
+    collected_formattings = []
+    for index, item in enumerate(parsed):
+        # Collect the indices of formatting items
+        if isinstance(item, Formatting):
+            collected_formattings.append(index)
+
+        # Only run checks if we have some collected formatting items
+        if len(collected_formattings) == 0:
+            continue
+
+        # If there's a string after some formattings, the formattings apply to it.
+        # This means they're not unused, remove them.
+        if isinstance(item, str) and not item.isspace():
+            collected_formattings = []
+            continue
+
+        # If there's a color after some formattings, these formattings will be overridden
+        # as colors reset everything. This makes these formattings pointless, mark them
+        # for removal.
+        if isinstance(item, (MinecraftColor, WebColor)):
+            to_remove.update(collected_formattings)
+            collected_formattings = []
+    return to_remove
+
+
+def get_empty_text(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Get indices of all empty text items.
+
+    Empty strings in motd serve no purpose and can be marked for removal.
+    """
+    to_remove: set[int] = set()
+
+    for index, item in enumerate(parsed):
+        if isinstance(item, str) and len(item) == 0:
+            to_remove.add(index)
+
+    return to_remove
+
+
+def get_end_non_text(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    """Get indices of all trailing items, found after the last text component.
+
+    Any color/formatting items only make sense when they apply to some text.
+    If there are some at the end, after the last text, they're pointless and
+    can be removed.
+    """
+    to_remove: set[int] = set()
+
+    for rev_index, item in enumerate(reversed(parsed)):
+        # The moment we find our last string, stop the loop
+        if isinstance(item, str):
+            break
+
+        # Remove any color/formatting that doesn't apply to text
+        if isinstance(item, (MinecraftColor, WebColor, Formatting)):
+            index = len(parsed) - 1 - rev_index
+            to_remove.add(index)
+
+    return to_remove
+
+
+def get_meaningless_resets_and_colors(parsed: Sequence[ParsedMotdComponent]) -> set[int]:
+    to_remove: set[int] = set()
+
+    active_color: MinecraftColor | WebColor | None = None
+    active_formatting: Formatting | None = None
+    for index, item in enumerate(parsed):
+        if isinstance(item, (MinecraftColor, WebColor)):
+            if active_color == item:
+                to_remove.add(index)
+            active_color = item
+            continue
+        if isinstance(item, Formatting):
+            if item == Formatting.RESET:
+                if active_color is None and active_formatting is None:
+                    to_remove.add(index)
+                    continue
+                active_color, active_formatting = None, None
+                continue
+            if active_formatting == item:
+                to_remove.add(index)
+            active_formatting = item
+
+    return to_remove