steamify 2.0.0__py3-none-any.whl

steamify/__init__.py

@@ -0,0 +1,12 @@
+"""Package that contains a lightweight converter between Markdown and Steam-compatible markup."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from steamify.markdown import to_markdown
+from steamify.steam import to_steam
+
+
+__version__ = version("steamify")
+__all__ = ["to_markdown", "to_steam"]

steamify/markdown.py

@@ -0,0 +1,284 @@
+"""Module that contains the Steam-markup-to-Markdown conversion pipeline."""
+
+from __future__ import annotations
+
+import re
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+_PATTERN_CODE_SPAN = re.compile(r"\[code\](.*?)\[/code\]")
+_PATTERN_IMAGE = re.compile(r"\[img\](.*?)\[/img\]")
+_PATTERN_LINK = re.compile(r"\[url=([^]]*)\](.*?)\[/url\]")
+_PATTERN_BOLD_ITALIC = re.compile(r"\[b\]\[i\](.*?)\[/i\]\[/b\]")
+_PATTERN_BOLD = re.compile(r"\[b\](.*?)\[/b\]")
+_PATTERN_ITALIC = re.compile(r"\[i\](.*?)\[/i\]")
+_PATTERN_STRIKETHROUGH = re.compile(r"\[strike\](.*?)\[/strike\]")
+
+_PATTERN_HEADING = re.compile(r"^\[h([1-6])\](.*)\[/h\1\]$")
+_PATTERN_HORIZONTAL_RULE = re.compile(r"^\[hr\]\[/hr\]$")
+_PATTERN_LIST_OPEN = re.compile(r"^\[(list|olist)\]$")
+_PATTERN_LIST_CLOSE = re.compile(r"^\[/(list|olist)\]$")
+_PATTERN_LIST_ITEM = re.compile(r"^\[\*\]\s?(.*)")
+_PATTERN_QUOTE_ONLY = re.compile(r"^(?:\[/?quote\])+$")
+_PATTERN_QUOTE_TOKEN = re.compile(r"\[(/?)quote\]")
+
+_INDENT_WIDTH = 2
+
+
+@dataclass
+class MarkdownState:  # noqa: D101
+    lines: list[str] = field(default_factory=list)
+    list_stack: list[tuple[str, int]] = field(default_factory=list)
+    current_quote_level: int = 0
+    inside_code_block: bool = False
+    code_block_accumulator: list[str] = field(default_factory=list)
+
+    def add_line(self, line: str) -> None:
+        self.lines.append(line)
+
+    def prefix(self, text: str) -> str:
+        return "> " * self.current_quote_level + text
+
+    def build(self) -> str:
+        return "\n".join(self.lines)
+
+
+def to_markdown(steam_text: str) -> str:
+    """Convert Steam-compatible markup to Markdown text."""
+    state = MarkdownState()
+    lines = steam_text.splitlines()
+
+    for steam_line in lines:
+        _process_line(steam_line, state)
+
+    _close_remaining_blocks(state)
+
+    return state.build()
+
+
+def _close_remaining_blocks(state: MarkdownState) -> None:
+    if state.inside_code_block:
+        state.inside_code_block = False
+        _flush_code_block(state)
+
+    state.list_stack.clear()
+    state.current_quote_level = 0
+
+
+def _process_line(steam_line: str, state: MarkdownState) -> None:
+    if state.inside_code_block:
+        _convert_code_block_content(steam_line, state)
+        return
+
+    line_content = steam_line.strip()
+
+    if line_content == "":
+        state.add_line("")
+        return
+
+    if (
+        _try_convert_code_block_open(line_content, state)
+        or _try_convert_quote_level(line_content, state)
+        or _try_convert_list_open(line_content, state)
+        or _try_convert_list_close(line_content, state)
+        or _try_convert_list_item(line_content, state)
+        or _try_convert_heading(line_content, state)
+        or _try_convert_horizontal_rule(line_content, state)
+    ):
+        return
+
+    state.add_line(state.prefix(_convert_inline_elements(line_content)))
+
+
+def _flush_code_block(state: MarkdownState) -> None:
+    state.add_line(state.prefix("```"))
+
+    for code_line in state.code_block_accumulator:
+        state.add_line(state.prefix(code_line))
+
+    state.add_line(state.prefix("```"))
+    state.code_block_accumulator.clear()
+
+
+def _try_convert_code_block_open(line_content: str, state: MarkdownState) -> bool:
+    """Enter code-block mode on a `[code]` tag left unclosed on its own line."""
+    if "[code]" not in line_content:
+        return False
+
+    leading_text, _, remainder = line_content.partition("[code]")
+    if "[/code]" in remainder:
+        return False
+
+    if leading_text.strip():
+        state.add_line(state.prefix(_convert_inline_elements(leading_text)))
+
+    state.inside_code_block = True
+    state.code_block_accumulator.clear()
+
+    if remainder:
+        state.code_block_accumulator.append(remainder)
+
+    return True
+
+
+def _convert_code_block_content(steam_line: str, state: MarkdownState) -> None:
+    if "[/code]" not in steam_line:
+        state.code_block_accumulator.append(steam_line)
+        return
+
+    code_content, _, trailing_text = steam_line.partition("[/code]")
+    if code_content:
+        state.code_block_accumulator.append(code_content)
+
+    state.inside_code_block = False
+    _flush_code_block(state)
+
+    if trailing_text.strip():
+        state.add_line(state.prefix(_convert_inline_elements(trailing_text)))
+
+
+def _try_convert_quote_level(line_content: str, state: MarkdownState) -> bool:
+    if not _PATTERN_QUOTE_ONLY.match(line_content):
+        return False
+
+    for token in _PATTERN_QUOTE_TOKEN.finditer(line_content):
+        if token.group(1):
+            state.current_quote_level = max(0, state.current_quote_level - 1)
+        else:
+            state.current_quote_level += 1
+
+    return True
+
+
+def _try_convert_list_open(line_content: str, state: MarkdownState) -> bool:
+    match = _PATTERN_LIST_OPEN.match(line_content)
+    if not match:
+        return False
+
+    state.list_stack.append((match.group(1), 0))
+
+    return True
+
+
+def _try_convert_list_close(line_content: str, state: MarkdownState) -> bool:
+    if not _PATTERN_LIST_CLOSE.match(line_content):
+        return False
+
+    if state.list_stack:
+        state.list_stack.pop()
+
+    return True
+
+
+def _try_convert_list_item(line_content: str, state: MarkdownState) -> bool:
+    match = _PATTERN_LIST_ITEM.match(line_content)
+    if not match:
+        return False
+
+    if not state.list_stack:
+        state.list_stack.append(("list", 0))
+
+    list_type, item_number = state.list_stack[-1]
+    item_number += 1
+    state.list_stack[-1] = (list_type, item_number)
+
+    match list_type:
+        case "olist":
+            marker = f"{item_number}."
+        case _:
+            marker = "-"
+
+    indent = " " * (_INDENT_WIDTH * (len(state.list_stack) - 1))
+    item_text = _convert_inline_elements(match.group(1))
+    state.add_line(state.prefix(f"{indent}{marker} {item_text}"))
+
+    return True
+
+
+def _try_convert_heading(line_content: str, state: MarkdownState) -> bool:
+    match = _PATTERN_HEADING.match(line_content)
+    if not match:
+        return False
+
+    level = int(match.group(1))
+    heading_text = _convert_inline_elements(match.group(2))
+    state.add_line(state.prefix(f"{'#' * level} {heading_text}"))
+
+    return True
+
+
+def _try_convert_horizontal_rule(line_content: str, state: MarkdownState) -> bool:
+    if not _PATTERN_HORIZONTAL_RULE.match(line_content):
+        return False
+
+    state.add_line(state.prefix("---"))
+
+    return True
+
+
+def _convert_inline_bold(text: str) -> str:
+    """Convert inline bold: [b]text[/b] -> **text**."""
+    text = _PATTERN_BOLD_ITALIC.sub(r"***\1***", text)
+    return _PATTERN_BOLD.sub(r"**\1**", text)
+
+
+def _convert_inline_elements(text: str) -> str:
+    text, code_spans = _convert_inline_code_spans(text)
+    text = _convert_inline_images(text)
+    text = _convert_inline_links(text)
+    text = _convert_inline_bold(text)
+    text = _convert_inline_italic(text)
+    text = _convert_inline_strikethrough(text)
+    text = _render_inline_code_spans(text, code_spans)
+    return text.strip()
+
+
+def _convert_inline_code_spans(text: str) -> tuple[str, list[str]]:
+    """Convert inline code spans: [code]code[/code] -> @@CODE{index}@@."""
+    code_spans: list[str] = []
+
+    def code_span_repl(match: re.Match) -> str:
+        code_content = match.group(1)
+        code_spans.append(code_content)
+        return f"@@CODE{len(code_spans) - 1}@@"
+
+    text = _PATTERN_CODE_SPAN.sub(code_span_repl, text)
+    return text, code_spans
+
+
+def _convert_inline_images(text: str) -> str:
+    """Convert inline images: [img]URL[/img] -> ![](URL)."""
+    return _PATTERN_IMAGE.sub(r"![](\1)", text)
+
+
+def _convert_inline_italic(text: str) -> str:
+    """Convert inline italic: [i]text[/i] -> *text*."""
+    return _PATTERN_ITALIC.sub(r"*\1*", text)
+
+
+def _convert_inline_links(text: str) -> str:
+    """Convert inline links: [url=URL]text[/url] -> [text](URL)."""
+
+    def link_repl(match: re.Match) -> str:
+        url = match.group(1)
+        link_text = match.group(2)
+        return f"[{link_text}]({url})"
+
+    return _PATTERN_LINK.sub(link_repl, text)
+
+
+def _convert_inline_strikethrough(text: str) -> str:
+    """Convert inline strikethrough: [strike]text[/strike] -> ~~text~~."""
+    return _PATTERN_STRIKETHROUGH.sub(r"~~\1~~", text)
+
+
+def _render_inline_code_spans(text: str, code_spans: list[str]) -> str:
+    """Render inline code spans: @@CODE{index}@@ -> `code`."""
+
+    def render_repl(match: re.Match) -> str:
+        idx = int(match.group(1))
+        return f"`{code_spans[idx]}`"
+
+    return re.sub(r"@@CODE(\d+)@@", render_repl, text)

steamify/steam.py

@@ -0,0 +1,357 @@
+"""Module that contains the Markdown-to-Steam-markup conversion pipeline."""
+
+from __future__ import annotations
+
+import re
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+_PATTERN_CODE_SPAN = re.compile(r"`([^`]+?)`")
+_PATTERN_IMAGE = re.compile(r'!\[.*?\]\(([^)\s"]+)(?:\s+"[^"]*")?\)')
+_PATTERN_LINK = re.compile(r'\[([^]]+)\]\(([^)\s"]+)(?:\s+"[^"]*")?\)')
+_PATTERN_BOLD_ITALIC_STAR = re.compile(r"\*\*\*(.*?)\*\*\*")
+_PATTERN_BOLD_ITALIC_UNDER = re.compile(r"___(.*?)___")
+_PATTERN_BOLD_STAR = re.compile(r"\*\*(.*?)\*\*")
+_PATTERN_BOLD_UNDER = re.compile(r"__(.*?)__")
+_PATTERN_ITALIC = re.compile(r"\*(.*?)\*")
+_PATTERN_STRIKETHROUGH = re.compile(r"~~(.*?)~~")
+
+_PATTERN_HEADING = re.compile(r"^(#{1,6})\s+(.*)")
+_PATTERN_HR_DASH = re.compile(r"^(-\s?){3,}$")
+_PATTERN_HR_UNDERSCORE = re.compile(r"^(_\s?){3,}$")
+_PATTERN_HR_STAR = re.compile(r"^(\*\s?){3,}$")
+_PATTERN_LIST_ITEM = re.compile(r"^(\s*)([-+*]|\d+\.)\s+(.*)")
+_PATTERN_LIST_MARKER = re.compile(r"^\s*([-+*]|\d+\.)\s+")
+
+
+@dataclass
+class SteamState:  # noqa: D101
+    lines: list[str] = field(default_factory=list)
+    list_stack: list[tuple[str, int]] = field(default_factory=list)
+    current_quote_level: int = 0
+    inside_code_block: bool = False
+    code_block_accumulator: list[str] = field(default_factory=list)
+
+    def add_line(self, line: str) -> None:
+        self.lines.append(line)
+
+    def close_lists(self) -> None:
+        while self.list_stack:
+            list_type, _ = self.list_stack.pop()
+            match list_type:
+                case "ol":
+                    tag = "olist"
+                case _:
+                    tag = "list"
+            self.add_line(f"[/{tag}]")
+
+    def close_quotes(self) -> None:
+        if self.current_quote_level > 0:
+            self.add_line("[/quote]" * self.current_quote_level)
+            self.current_quote_level = 0
+
+    def build(self) -> str:
+        return "\n".join(self.lines)
+
+
+def to_steam(markdown_text: str) -> str:
+    """Convert Markdown text to Steam-compatible markup."""
+    state = SteamState()
+    lines = markdown_text.splitlines()
+
+    for md_line in lines:
+        _process_line(md_line, state)
+
+    _close_remaining_blocks(state)
+
+    return state.build()
+
+
+def _close_remaining_blocks(state: SteamState) -> None:
+    if state.inside_code_block:
+        code_content = "\n".join(state.code_block_accumulator)
+        state.add_line(f"[code]{code_content}[/code]")
+
+    state.close_lists()
+    state.close_quotes()
+
+
+def _process_line(md_line: str, state: SteamState) -> None:
+    if state.inside_code_block:
+        _convert_code_block_content(md_line, state)
+        return
+
+    if md_line.strip().startswith("```"):
+        state.inside_code_block = True
+        state.code_block_accumulator.clear()
+        return
+
+    if md_line.strip() == "":
+        _convert_empty_line(state)
+        return
+
+    _check_list_continuation(md_line, state)
+
+    line_content, quote_depth = _extract_quotes(md_line)
+    _convert_quote_level(quote_depth, state)
+
+    if _try_convert_heading(line_content, state):
+        return
+    if _try_convert_horizontal_rule(line_content, state):
+        return
+    if _try_convert_list_item(line_content, state):
+        return
+
+    state.add_line(_convert_inline_elements(line_content))
+
+
+def _convert_code_block_content(md_line: str, state: SteamState) -> None:
+    if md_line.strip().startswith("```"):
+        state.inside_code_block = False
+        code_content = "\n".join(state.code_block_accumulator)
+        state.add_line(f"[code]{code_content}[/code]")
+        state.code_block_accumulator.clear()
+
+    else:
+        state.code_block_accumulator.append(md_line)
+
+
+def _convert_empty_line(state: SteamState) -> None:
+    state.close_lists()
+    state.close_quotes()
+    state.add_line("")
+
+
+def _adjust_list_stack(list_type: str, indent_spaces: int, state: SteamState) -> None:
+    if not state.list_stack:
+        state.list_stack.append((list_type, indent_spaces))
+        match list_type:
+            case "ol":
+                tag = "olist"
+            case _:
+                tag = "list"
+        state.add_line(f"[{tag}]")
+        return
+
+    current_indent = state.list_stack[-1][1]
+
+    if indent_spaces > current_indent:
+        state.list_stack.append((list_type, indent_spaces))
+        match list_type:
+            case "ol":
+                tag = "olist"
+            case _:
+                tag = "list"
+        state.add_line(f"[{tag}]")
+
+    elif indent_spaces < current_indent:
+        _convert_list_dedent(list_type, indent_spaces, state)
+
+    else:
+        _convert_list_same_level(list_type, indent_spaces, state)
+
+
+def _check_list_continuation(md_line: str, state: SteamState) -> None:
+    if not state.list_stack:
+        return
+
+    if not _PATTERN_LIST_MARKER.match(md_line):
+        leading_spaces = len(md_line) - len(md_line.lstrip(" "))
+        first_char = md_line.lstrip(" ")[:1]
+        is_quote_and_indented = first_char == ">" and leading_spaces > state.list_stack[-1][1]
+        if not is_quote_and_indented:
+            state.close_lists()
+
+
+def _convert_list_dedent(list_type: str, indent_spaces: int, state: SteamState) -> None:
+    while state.list_stack and indent_spaces < state.list_stack[-1][1]:
+        prev_type, _ = state.list_stack.pop()
+        match prev_type:
+            case "ol":
+                tag = "olist"
+            case _:
+                tag = "list"
+        state.add_line(f"[/{tag}]")
+
+    if state.list_stack and state.list_stack[-1][1] == indent_spaces:
+        if state.list_stack[-1][0] != list_type:
+            prev_type, _ = state.list_stack.pop()
+            match prev_type:
+                case "ol":
+                    old_tag = "olist"
+                case _:
+                    old_tag = "list"
+            match list_type:
+                case "ol":
+                    new_tag = "olist"
+                case _:
+                    new_tag = "list"
+            state.add_line(f"[/{old_tag}]")
+            state.list_stack.append((list_type, indent_spaces))
+            state.add_line(f"[{new_tag}]")
+
+    else:
+        state.list_stack.append((list_type, indent_spaces))
+        match list_type:
+            case "ol":
+                tag = "olist"
+            case _:
+                tag = "list"
+        state.add_line(f"[{tag}]")
+
+
+def _convert_list_same_level(list_type: str, indent_spaces: int, state: SteamState) -> None:
+    if state.list_stack[-1][0] != list_type:
+        prev_type, _ = state.list_stack.pop()
+        match prev_type:
+            case "ol":
+                old_tag = "olist"
+            case _:
+                old_tag = "list"
+        match list_type:
+            case "ol":
+                new_tag = "olist"
+            case _:
+                new_tag = "list"
+        state.add_line(f"[/{old_tag}]")
+        state.list_stack.append((list_type, indent_spaces))
+        state.add_line(f"[{new_tag}]")
+
+
+def _try_convert_list_item(line_content: str, state: SteamState) -> bool:
+    match = _PATTERN_LIST_ITEM.match(line_content)
+    if not match:
+        return False
+
+    indent_str = match.group(1)
+    marker = match.group(2)
+    item_text = match.group(3)
+    indent_spaces = len(indent_str.expandtabs(4))
+    list_type = "ol" if marker.rstrip(".").isdigit() else "ul"
+
+    _adjust_list_stack(list_type, indent_spaces, state)
+
+    converted_item = _convert_inline_elements(item_text)
+    state.add_line(f"[*] {converted_item}")
+
+    return True
+
+
+def _convert_quote_level(quote_depth: int, state: SteamState) -> None:
+    match quote_depth:
+        case 0:
+            state.close_quotes()
+        case _:
+            if quote_depth > state.current_quote_level:
+                for _ in range(state.current_quote_level, quote_depth):
+                    state.add_line("[quote]")
+            elif quote_depth < state.current_quote_level:
+                for _ in range(quote_depth, state.current_quote_level):
+                    state.add_line("[/quote]")
+            state.current_quote_level = quote_depth
+
+
+def _extract_quotes(md_line: str) -> tuple[str, int]:
+    stripped_line = md_line
+    quote_depth = 0
+
+    while stripped_line.startswith(">"):
+        quote_depth += 1
+        stripped_line = stripped_line.removeprefix(">").removeprefix(" ")
+
+    return stripped_line, quote_depth
+
+
+def _try_convert_heading(line_content: str, state: SteamState) -> bool:
+    match = _PATTERN_HEADING.match(line_content)
+    if not match:
+        return False
+
+    level = min(len(match.group(1)), 3)  # Steam supports h1-h3
+    heading_text = match.group(2)
+    converted_heading = _convert_inline_elements(heading_text)
+    state.add_line(f"[h{level}]{converted_heading}[/h{level}]")
+
+    return True
+
+
+def _try_convert_horizontal_rule(line_content: str, state: SteamState) -> bool:
+    if (
+        _PATTERN_HR_DASH.match(line_content)
+        or _PATTERN_HR_UNDERSCORE.match(line_content)
+        or _PATTERN_HR_STAR.match(line_content)
+    ):
+        state.add_line("[hr][/hr]")
+        return True
+
+    return False
+
+
+def _convert_inline_bold(text: str) -> str:
+    """Convert inline bold: **text** -> [b]text[/b]."""
+    text = _PATTERN_BOLD_ITALIC_STAR.sub(r"[b][i]\1[/i][/b]", text)
+    text = _PATTERN_BOLD_ITALIC_UNDER.sub(r"[b][i]\1[/i][/b]", text)
+    text = _PATTERN_BOLD_STAR.sub(r"[b]\1[/b]", text)
+    return _PATTERN_BOLD_UNDER.sub(r"[b]\1[/b]", text)
+
+
+def _convert_inline_elements(text: str) -> str:
+    text, code_spans = _convert_inline_code_spans(text)
+    text = _convert_inline_images(text)
+    text = _convert_inline_links(text)
+    text = _convert_inline_bold(text)
+    text = _convert_inline_italic(text)
+    text = _convert_inline_strikethrough(text)
+    text = _render_inline_code_spans(text, code_spans)
+    return text.strip()
+
+
+def _convert_inline_code_spans(text: str) -> tuple[str, list[str]]:
+    """Convert inline code spans: ``code`` -> @@CODE{index}@@."""
+    code_spans: list[str] = []
+
+    def code_span_repl(match: re.Match) -> str:
+        code_content = match.group(1)
+        code_spans.append(code_content)
+        return f"@@CODE{len(code_spans) - 1}@@"
+
+    text = _PATTERN_CODE_SPAN.sub(code_span_repl, text)
+    return text, code_spans
+
+
+def _convert_inline_images(text: str) -> str:
+    """Convert inline images: ![alt](URL) -> [img]URL[/img]."""
+    return _PATTERN_IMAGE.sub(r"[img]\1[/img]", text)
+
+
+def _convert_inline_italic(text: str) -> str:
+    """Convert inline italic: *text* -> [i]text[/i]."""
+    return _PATTERN_ITALIC.sub(r"[i]\1[/i]", text)
+
+
+def _convert_inline_links(text: str) -> str:
+    """Convert inline links: [text](URL) -> [url=URL]text[/url]."""
+
+    def link_repl(match: re.Match) -> str:
+        link_text = match.group(1)
+        url = match.group(2)
+        return f"[url={url}]{link_text}[/url]"
+
+    return _PATTERN_LINK.sub(link_repl, text)
+
+
+def _convert_inline_strikethrough(text: str) -> str:
+    """Convert inline strikethrough: ~~text~~ -> [strike]text[/strike]."""
+    return _PATTERN_STRIKETHROUGH.sub(r"[strike]\1[/strike]", text)
+
+
+def _render_inline_code_spans(text: str, code_spans: list[str]) -> str:
+    """Render inline code spans: @@CODE{index}@@ -> [code]code[/code]."""
+
+    def render_repl(match: re.Match) -> str:
+        idx = int(match.group(1))
+        return f"[code]{code_spans[idx]}[/code]"
+
+    return re.sub(r"@@CODE(\d+)@@", render_repl, text)

steamify-2.0.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.5
+Name: steamify
+Version: 2.0.0
+Summary: A lightweight package for converting Markdown into Steam-compatible markup, and back again.
+Project-URL: Homepage, https://github.com/pivoshenko/steamify
+Project-URL: Repository, https://github.com/pivoshenko/steamify
+Author-email: Volodymyr Pivoshenko <contact@pivoshenko.dev>
+Maintainer-email: Volodymyr Pivoshenko <contact@pivoshenko.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bbcode,converter,formatter,gaming,markdown,markup,parser,steam,steam-bbcode,steam-bbcode-converter,steam-workshop,steamify,text-processing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Steamify
+
+<p align="left">
+  <a href="https://pypi.org/project/steamify">
+    <img alt="Python" src="https://img.shields.io/pypi/pyversions/steamify?style=flat-square&logo=python&logoColor=white&color=4856CD&label=Python">
+  </a>
+  <a href="https://pypi.org/project/steamify">
+    <img alt="PyPI" src="https://img.shields.io/pypi/v/steamify?style=flat-square&logo=pypi&logoColor=white&color=4856CD&label=PyPI">
+  </a>
+  <a href="https://github.com/pivoshenko/steamify/actions/workflows/ci.yaml">
+    <img alt="CI" src="https://img.shields.io/github/actions/workflow/status/pivoshenko/steamify/ci.yaml?label=CI&style=flat-square&logo=githubactions&logoColor=white&color=0A6847">
+  </a>
+  <a href="https://docs.astral.sh/ruff">
+    <img alt="Ruff" src="https://img.shields.io/badge/Style-ruff-black.svg?style=flat-square&logo=ruff&logoColor=white&color=D7FF64">
+  </a>
+  <a href="https://stand-with-ukraine.pp.ua">
+    <img alt="StandWithUkraine" src="https://img.shields.io/badge/Support-Ukraine-FFC93C?style=flat-square&labelColor=07689F">
+  </a>
+</p>
+
+## Overview
+
+A lightweight package for converting Markdown into Steam-compatible markup, and back again.
+
+### About the Name
+
+*Steamify* is what the package does: it takes Markdown and makes it Steam-flavoured, and it reads Steam markup back into Markdown. It was extracted from [Ihroteka](https://ihroteka.com), a personal game-library app, and released standalone.
+
+## Features
+
+Zero runtime dependencies, and conversion in both directions.
+
+### Markdown -> Steam
+
+- Headings (`#` to `######`) -> `[h1]` to `[h3]`, since Steam caps at three levels
+- Bold, italic, strikethrough, inline code
+- Links and images -> `[url]` / `[img]`
+- Ordered and unordered lists (nested)
+- Blockquotes (nested)
+- Fenced code blocks -> `[code]`
+- Horizontal rules -> `[hr][/hr]`
+
+### Steam -> Markdown
+
+- `[h1]` to `[h6]` -> `#` to `######`
+- `[b]`, `[i]`, `[strike]`, `[code]` -> `**`, `*`, `~~`, backticks
+- `[url]` / `[img]` -> Markdown links and images
+- `[list]` / `[olist]` (nested) -> `-` / `1.`
+- `[quote]` (nested) -> `>`
+- `[hr][/hr]` -> `---`
+- Steam-only tags such as `[spoiler]`, `[noparse]`, `[table]`, and `[u]` have no Markdown
+  equivalent, so they pass through verbatim rather than being dropped
+
+### Round-tripping
+
+`to_steam(to_markdown(steam))` returns the original markup, so a Steam -> Markdown -> Steam cycle
+is stable. The Markdown side is normalized rather than preserved byte for byte:
+
+- `####` and deeper collapse into `[h3]` on the way out, and come back as `###`
+- Image alt text is not carried by `[img]`, so it returns empty
+- A single-line fenced block returns as an inline code span
+
+## Installation
+
+Install with pip or uv:
+
+```shell
+pip install -U steamify
+
+uv add steamify
+```
+
+## Usage
+
+```python
+from steamify import to_steam
+
+md_text = """
+# My Game Guide
+
+Welcome to the **best** game ever!
+
+## Features
+
+- Easy to learn
+- *Beautiful* graphics
+- ~~Microtransactions~~ Free to play!
+
+Check out the [wiki](https://example.com) for tips.
+"""
+
+steam_text = to_steam(md_text)
+print(steam_text)
+
+# [h1]My Game Guide[/h1]
+
+# Welcome to the [b]best[/b] game ever!
+
+# [h2]Features[/h2]
+
+# [list]
+# [*] Easy to learn
+# [*] [i]Beautiful[/i] graphics
+# [*] [strike]Microtransactions[/strike] Free to play!
+# [/list]
+
+# Check out the [url=https://example.com]wiki[/url] for tips.
+```
+
+Converting the other way:
+
+```python
+from steamify import to_markdown
+
+steam_text = """
+[h1]Patch Notes[/h1]
+
+[list]
+[*] Fixed [b]crash[/b] on startup
+[*] [spoiler]Secret boss[/spoiler] added
+[/list]
+"""
+
+md_text = to_markdown(steam_text)
+print(md_text)
+
+# # Patch Notes
+
+# - Fixed **crash** on startup
+# - [spoiler]Secret boss[/spoiler] added
+```

steamify-2.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+steamify/__init__.py,sha256=Y-6ETp_g2JW9EGiP12QD-IU832iXNMUZPwU_Q5pnX2w,327
+steamify/markdown.py,sha256=7BvOP0FJ2Fvqo5YhVVfzzgWNzyTi22K-jvLVjstOad4,8522
+steamify/steam.py,sha256=X0mw3uEFVq6lAUoBhhLLC0hleZ9sOmorFCP63tvLWDo,11368
+steamify-2.0.0.dist-info/METADATA,sha256=L1UdCAYyyJPyZyX-an18ROFIInglLLp5j6--asMySBo,5211
+steamify-2.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+steamify-2.0.0.dist-info/licenses/LICENSE,sha256=R36dvI8PbhpvRn28yiVrSJLd3pppTkcbjtqvMmbOzkU,1077
+steamify-2.0.0.dist-info/RECORD,,

steamify-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

steamify-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Volodymyr Pivoshenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.