md2linkedin 0.2.2__tar.gz → 0.3.0__tar.gz

{md2linkedin-0.2.2 → md2linkedin-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: md2linkedin
-Version: 0.2.2
+Version: 0.3.0
 Summary: Convert Markdown to LinkedIn-friendly Unicode text
 Keywords: markdown,linkedin,unicode,formatting,conversion
 Author: Indrajeet Patil
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Text Processing :: Markup
 Classifier: Topic :: Utilities
-Requires-Dist: click>=8.3.3
+Requires-Dist: click>=8.5.0
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/IndrajeetPatil/md2linkedin
 Project-URL: Documentation, https://www.indrapatil.com/md2linkedin/
@@ -53,6 +53,9 @@ natively.
 | pip             | `pip install md2linkedin` |
 | uv              | `uv add md2linkedin`      |
 
+> **Tip:** Run the CLI without installing it with
+> `uvx md2linkedin post.md`.
+
 ## Usage
 
 ### Python API
@@ -85,6 +88,7 @@ print(convert(md))
     I'm thrilled to share that 𝘄𝗲 𝗷𝘂𝘀𝘁 𝗹𝗮𝘂𝗻𝗰𝗵𝗲𝗱 a new product!
 
     Key highlights:
+
     • 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: 3𝘹 𝘧𝘢𝘴𝘵𝘦𝘳 than the previous version
     • 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝙯𝙚𝙧𝙤 𝙙𝙤𝙬𝙣𝙩𝙞𝙢𝙚 deployments
     • 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗨𝗫: clean, intuitive API
@@ -158,6 +162,10 @@ notable limitations:
 For more examples, check out the package documentation at:
 <https://www.indrapatil.com/md2linkedin/>
 
+## See Also
+
+- [md2linkedin Web App](https://019d695e-8448-ee38-5db3-7ca4acf2ce2c.share.connect.posit.cloud/) — an interactive web interface for `md2linkedin`, built by [Yann Cohen](https://github.com/iamYannC).
+
 ## License
 
 This project is licensed under the MIT License.

{md2linkedin-0.2.2 → md2linkedin-0.3.0}/README.md

@@ -21,6 +21,9 @@ natively.
 | pip             | `pip install md2linkedin` |
 | uv              | `uv add md2linkedin`      |
 
+> **Tip:** Run the CLI without installing it with
+> `uvx md2linkedin post.md`.
+
 ## Usage
 
 ### Python API
@@ -53,6 +56,7 @@ print(convert(md))
     I'm thrilled to share that 𝘄𝗲 𝗷𝘂𝘀𝘁 𝗹𝗮𝘂𝗻𝗰𝗵𝗲𝗱 a new product!
 
     Key highlights:
+
     • 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: 3𝘹 𝘧𝘢𝘴𝘵𝘦𝘳 than the previous version
     • 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝙯𝙚𝙧𝙤 𝙙𝙤𝙬𝙣𝙩𝙞𝙢𝙚 deployments
     • 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗨𝗫: clean, intuitive API
@@ -126,6 +130,10 @@ notable limitations:
 For more examples, check out the package documentation at:
 <https://www.indrapatil.com/md2linkedin/>
 
+## See Also
+
+- [md2linkedin Web App](https://019d695e-8448-ee38-5db3-7ca4acf2ce2c.share.connect.posit.cloud/) — an interactive web interface for `md2linkedin`, built by [Yann Cohen](https://github.com/iamYannC).
+
 ## License
 
 This project is licensed under the MIT License.

md2linkedin-0.3.0/pyproject.toml

@@ -0,0 +1,157 @@
+[project]
+name = "md2linkedin"
+version = "0.3.0"
+description = "Convert Markdown to LinkedIn-friendly Unicode text"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE.md"]
+keywords = [
+    "markdown",
+    "linkedin",
+    "unicode",
+    "formatting",
+    "conversion",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Utilities",
+]
+dependencies = ["click>=8.5.0"]
+
+[[project.authors]]
+name = "Indrajeet Patil"
+email = "patilindrajeet.science@gmail.com"
+
+[project.scripts]
+md2linkedin = "md2linkedin._cli:main"
+
+[project.urls]
+Homepage = "https://github.com/IndrajeetPatil/md2linkedin"
+Documentation = "https://www.indrapatil.com/md2linkedin/"
+Repository = "https://github.com/IndrajeetPatil/md2linkedin"
+Issues = "https://github.com/IndrajeetPatil/md2linkedin/issues"
+Changelog = "https://github.com/IndrajeetPatil/md2linkedin/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+dev = [
+    "add-trailing-comma>=4.0.0",
+    "coverage>=7.16.1",
+    "jupyter>=1.1.1",
+    "mkdocstrings-python>=2.0.8",
+    "mutmut>=3.8.0",
+    "prek>=0.5.3",
+    "pytest>=9.1.1",
+    "pytest-codspeed==5.0.3",
+    "pytest-cov>=7.1.0",
+    "pytest-random-order>=1.2.0",
+    "pyyaml>=6.0.3",
+    "ruff>=0.16.8",
+    "ty>=0.0.82",
+    "zensical>=0.0.62",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13"]
+build-backend = "uv_build"
+
+[tool.ruff]
+fix = true
+preview = true
+unsafe-fixes = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "missing-trailing-comma",
+    "incorrect-blank-line-before-class",
+    "multi-line-summary-second-line",
+    "CPY",
+    "ambiguous-unicode-character-docstring",
+    "ambiguous-unicode-character-comment",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = [
+    "D",
+    "assert",
+    "import-private-name",
+    "no-self-use",
+    "ambiguous-unicode-character-string",
+    "magic-value-comparison",
+    "too-many-public-methods",
+]
+
+[tool.ruff.format]
+preview = true
+docstring-code-format = true
+
+[tool.pytest.ini_options]
+addopts = [
+    "--strict-config",
+    "--strict-markers",
+    "-ra",
+    "--verbose",
+    "--random-order",
+]
+testpaths = ["tests"]
+filterwarnings = ["error"]
+xfail_strict = true
+python_files = [
+    "test_*.py",
+    "test-*.py",
+    "tests.py",
+    "test.py",
+]
+
+[tool.coverage.run]
+branch = true
+source = ["md2linkedin"]
+
+[tool.coverage.report]
+fail_under = 100
+format = "markdown"
+sort = "-Cover"
+show_missing = true
+skip_empty = true
+
+[tool.mutmut]
+source_paths = ["src/md2linkedin/"]
+also_copy = ["scripts/"]
+pytest_add_cli_args_test_selection = ["tests/"]
+mutate_only_covered_lines = true
+do_not_mutate_patterns = ['closing_fence = rest\.rfind\(fence\)']
+
+[tool.ty.src]
+exclude = [
+    ".venv",
+    "build",
+    "dist",
+    "docs",
+]
+
+[tool.ty.environment]
+python-version = "3.10"
+
+[tool.ty.rules]
+all = "error"
+
+[tool.ty.analysis]
+respect-type-ignore-comments = false
+strict-equality-semantics = true
+strict-generic-narrowing = true
+
+[tool.uv]
+required-version = ">=0.12.0"

md2linkedin-0.2.2/pyproject.toml → md2linkedin-0.3.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "md2linkedin"
-version = "0.2.2"
+version = "0.3.0"
 description = "Convert Markdown to LinkedIn-friendly Unicode text"
 readme = "README.md"
 authors = [
@@ -26,7 +26,9 @@ classifiers = [
     "Topic :: Text Processing :: Markup",
     "Topic :: Utilities",
 ]
-dependencies = ["click>=8.3.3"]
+dependencies = [
+    "click>=8.5.0",
+]
 
 [project.scripts]
 md2linkedin = "md2linkedin._cli:main"
@@ -40,21 +42,24 @@ Changelog = "https://github.com/IndrajeetPatil/md2linkedin/blob/main/CHANGELOG.m
 
 [dependency-groups]
 dev = [
-    "coverage>=7.13.5",
+    "add-trailing-comma>=4.0.0",
+    "coverage>=7.16.1",
     "jupyter>=1.1.1",
-    "zensical>=0.0.36",
-    "mkdocstrings-python>=2.0.3",
-    "ty>=0.0.32",
-    "prek>=0.3.10",
-    "pytest>=9.0.3",
+    "mkdocstrings-python>=2.0.8",
+    "mutmut>=3.8.0",
+    "prek>=0.5.3",
+    "pytest>=9.1.1",
+    "pytest-codspeed==5.0.3",
     "pytest-cov>=7.1.0",
     "pytest-random-order>=1.2.0",
-    "ruff>=0.15.11",
-    "add-trailing-comma>=4.0.0",
+    "pyyaml>=6.0.3",
+    "ruff>=0.16.8",
+    "ty>=0.0.82",
+    "zensical>=0.0.62",
 ]
 
 [build-system]
-requires = ["uv_build>=0.11.2,<0.12"]
+requires = ["uv_build>=0.12.0,<0.13"]
 build-backend = "uv_build"
 
 [tool.ruff]
@@ -65,39 +70,35 @@ unsafe-fixes = true
 [tool.ruff.lint]
 select = ["ALL"]
 ignore = [
-    "COM812",
+    # Required for compatibility with Ruff's formatter.
+    "missing-trailing-comma",
+    # Mutually exclusive with D211 and D212, respectively.
+    "incorrect-blank-line-before-class",
+    "multi-line-summary-second-line",
+    # This project uses a repository-level LICENSE instead of per-file notices.
     "CPY",
-    # Docstring content rules — we intentionally omit Returns/Raises sections
-    # in internal helpers, consistent with ignoring D (pydocstyle) above.
-    "D",
-    "DOC",
     # This package's output IS Unicode Mathematical characters; having them in
     # docstring examples and block-comment separators is intentional.
-    "RUF002",
-    "RUF003",
+    "ambiguous-unicode-character-docstring",
+    "ambiguous-unicode-character-comment",
 ]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
     # docstring requirements
     "D",
-    "DOC",
     # tests can use asserts
-    "S101",
-    # pytest fixtures (e.g. tmp_path) don't need type annotations
-    "ANN001",
+    "assert",
     # tests legitimately import private internals to test them directly
-    "PLC2701",
+    "import-private-name",
     # test methods inside classes don't need @staticmethod — class grouping is intentional
-    "PLR6301",
+    "no-self-use",
     # test assertions for Unicode output use the literal Unicode chars (intentional)
-    "RUF001",
-    # `== ""` vs `not x` — both forms are acceptable in assertions
-    "PLC1901",
+    "ambiguous-unicode-character-string",
     # magic numbers in assertions are fine (e.g. expected count == 3)
-    "PLR2004",
+    "magic-value-comparison",
     # large test classes are fine when grouping related cases
-    "PLR0904",
+    "too-many-public-methods",
 ]
 
 [tool.ruff.format]
@@ -133,11 +134,48 @@ sort = "-Cover"
 show_missing = true
 skip_empty = true
 
+[tool.mutmut]
+source_paths = ["src/md2linkedin/"]
+# The regression-gate tests import the comparator from this support package.
+also_copy = ["scripts/"]
+pytest_add_cli_args_test_selection = ["tests/"]
+# Only mutate lines exercised by the test suite so mutmut concentrates on
+# meaningful mutations that the tests should actually catch.
+mutate_only_covered_lines = true
+# Skip mutations that cannot be detected by the tests in practice. The
+# pattern is hoisted onto its own source line so the line-granularity
+# exclusion below suppresses only the equivalence mutation described and
+# not any other operations on the same statement.
+# * ``closing_fence = rest.rfind(fence)`` on a fenced code block is
+#   equivalent to ``rest.find(fence)`` because the non-greedy regex that
+#   captured the block already trims to the shortest matching span, so
+#   no additional ``fence`` marker can appear inside ``rest``.
+#
+# ``encoding=_ENCODING`` mutations (``encoding=None`` / arg-removal) are
+# NOT excluded here — they are covered by focused tests that assert the
+# UTF-8 argument is passed explicitly, so surviving mutants would show up
+# as real test failures rather than being silently skipped.
+do_not_mutate_patterns = [
+    'closing_fence = rest\.rfind\(fence\)',
+]
+
 [tool.ty.src]
 exclude = [".venv", "build", "dist", "docs"]
 
 [tool.ty.environment]
 python-version = "3.10"
 
+[tool.ty.rules]
+# Enable every current diagnostic, including soundness and suppression checks that
+# ty leaves disabled by default. Pinning ty in uv.lock keeps new rules from arriving
+# silently between dependency updates.
+all = "error"
+
+[tool.ty.analysis]
+# Prefer sound narrowing over convenience assumptions at external-data boundaries.
+respect-type-ignore-comments = false
+strict-equality-semantics = true
+strict-generic-narrowing = true
+
 [tool.uv]
-required-version = ">=0.11.2"
+required-version = ">=0.12.0"

{md2linkedin-0.2.2 → md2linkedin-0.3.0}/src/md2linkedin/_cli.py

@@ -1,4 +1,4 @@
-"""Command-line interface for md2linkedin."""
+"""Command-line interface for converting Markdown with md2linkedin."""
 
 from __future__ import annotations
 
@@ -54,7 +54,7 @@ def main(
     preserve_links: bool,
     no_monospace_code: bool,
 ) -> None:
-    """Convert Markdown to LinkedIn-friendly Unicode text.
+    r"""Convert Markdown to LinkedIn-friendly Unicode text.
 
     Reads from INPUT_FILE (or stdin when INPUT_FILE is omitted) and writes
     LinkedIn-compatible plain text in which bold and italic formatting is
@@ -80,6 +80,10 @@ def main(
 
       # Disable monospace code rendering
       md2linkedin README.md --no-monospace-code
+
+    Raises:
+        click.UsageError: If neither an input file nor piped stdin is provided.
+
     """
     monospace_code = not no_monospace_code
     if input_file is not None:
@@ -112,5 +116,9 @@ def _stdin_is_tty() -> bool:
 
     Extracted into its own function so tests can mock it cleanly without
     fighting Click's own stdin-swapping inside ``CliRunner.invoke``.
+
+    Returns:
+        Whether stdin is connected to an interactive terminal.
+
     """
-    return sys.stdin.isatty()
+    return bool(sys.stdin.isatty())

{md2linkedin-0.2.2 → md2linkedin-0.3.0}/src/md2linkedin/_converter.py

@@ -8,28 +8,64 @@ regex conflicts (e.g. bold-italic must be processed before bold or italic).
 from __future__ import annotations
 
 import re
-import uuid
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from ._unicode import to_monospace, to_sans_bold, to_sans_bold_italic, to_sans_italic
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 __all__ = ["convert", "convert_file"]
 
 _NESTED_BULLET_MIN_INDENT = 2  # spaces of indentation that triggers a nested bullet (‣)
+_ENCODING = "utf-8"
+
+_HTML_ENTITIES = {
+    ">": ">",
+    "&lt;": "<",
+    "&amp;": "&",
+    "&nbsp;": " ",
+    "&quot;": '"',
+    "&apos;": "'",
+}
 
 # ── Low-level pipeline steps ───────────────────────────────────────────────────
 
 
 def _normalize_line_endings(text: str) -> str:
-    """Normalize Windows (\\r\\n) and classic Mac (\\r) line endings to \\n."""
+    r"""Normalize Windows (\\r\\n) and classic Mac (\\r) line endings to \\n.
+
+    Returns:
+        Text containing only Unix-style line endings.
+
+    """
     return text.replace("\r\n", "\n").replace("\r", "\n")
 
 
+# Placeholder bodies are drawn from the Private Use Area (U+E000+). A
+# placeholder has to survive every step between _protect_code and
+# _restore_code untouched, and those steps rewrite ASCII alphanumerics
+# (to_sans_*) or apply .upper(). PUA codepoints are immune to both, whereas an
+# ASCII body gets mangled and the placeholder then leaks into the output (#63).
+_PLACEHOLDER_BASE = 0xE000
+# Matches any key built above. Restoring via one regex pass beats a str.replace
+# per key: the keys are only three characters, and CPython's substring search
+# skips much less on a short needle, so repeated scans of a long document
+# dominated the conversion.
+_PLACEHOLDER_RE = re.compile(r"\x00.\x00", re.DOTALL)
+
+
 def _protect_code(text: str) -> tuple[str, dict[str, str]]:
-    """Replace code spans and fenced blocks with unique placeholders.
+    r"""Replace code spans and fenced blocks with unique placeholders.
 
     Code content must never be transformed by the Unicode mapping steps.
-    Placeholders are UUID-based so they cannot accidentally match user text.
+
+    Each placeholder is a Private Use Area character delimited by ``\x00``,
+    chosen so that no later pipeline step can alter it; see
+    :data:`_PLACEHOLDER_BASE`. Any ``\x00`` already in *text* is dropped,
+    which is what keeps the sequentially numbered keys from colliding with
+    content that happens to contain Private Use Area characters.
 
     Args:
         text: Markdown text.
@@ -37,11 +73,13 @@ def _protect_code(text: str) -> tuple[str, dict[str, str]]:
     Returns:
         A ``(modified_text, placeholder_map)`` tuple where *placeholder_map*
         maps each placeholder back to its original code string.
+
     """
+    text = text.replace("\x00", "")
     placeholders: dict[str, str] = {}
 
     def _replace(match: re.Match[str]) -> str:
-        key = f"\x00CODE{uuid.uuid4().hex}\x00"
+        key = f"\x00{chr(_PLACEHOLDER_BASE + len(placeholders))}\x00"
         placeholders[key] = match.group(0)
         return key
 
@@ -69,6 +107,12 @@ def _restore_code(
     mapped; all other characters (including Markdown syntax) pass through
     unchanged, so no nested processing is needed.
 
+    All placeholders are expanded in a single pass, repeated until the text
+    stops changing. :func:`_protect_code` matches fenced blocks before inline
+    spans, so an inline span that wraps a fenced run swallows the fenced
+    placeholder into its own stored value; expanding the outer span
+    reintroduces the inner key, which the next pass resolves.
+
     Args:
         text: Text containing placeholders.
         placeholders: Map of placeholder → original code string.
@@ -76,28 +120,37 @@ def _restore_code(
 
     Returns:
         Text with all placeholders replaced by their original code content.
+
     """
-    for key, original in placeholders.items():
+
+    def _expand(match: re.Match[str]) -> str:
+        original = placeholders[match.group(0)]
         if original.startswith(("```", "~~~")):
             if monospace:
                 # Strip fences and optional language tag, convert content
                 fence = original[:3]
                 rest = original[3:]
                 # Remove closing fence
-                body = rest[: rest.rfind(fence)]
-                # Strip optional language tag (first line of body)
-                first_nl = body.find("\n")
-                content = body[first_nl + 1 :] if first_nl != -1 else ""
-                text = text.replace(key, to_monospace(content))
-            else:
-                # Keep fenced blocks as-is (no backtick stripping)
-                text = text.replace(key, original)
-        elif monospace:
+                closing_fence = rest.rfind(fence)
+                body = rest[:closing_fence]
+                # Strip the optional language tag, which is only a language tag
+                # when a newline terminates it. A single-line run (```hi```) has
+                # no tag, so find returns -1 and the slice keeps the whole body.
+                content = body[body.find("\n") + 1 :]
+                return to_monospace(content)
+            # Keep fenced blocks as-is (no backtick stripping)
+            return original
+        if monospace:
             # Strip backticks and apply monospace for inline code
-            text = text.replace(key, to_monospace(original[1:-1]))
-        else:
-            # Strip the surrounding backticks for inline code
-            text = text.replace(key, original[1:-1])
+            return to_monospace(original[1:-1])
+        # Strip the surrounding backticks for inline code
+        return original[1:-1]
+
+    while placeholders:
+        new_text = _PLACEHOLDER_RE.sub(_expand, text)
+        if new_text == text:
+            break
+        text = new_text
     return text
 
 
@@ -112,16 +165,56 @@ def _strip_html_spans(text: str) -> str:
 
     Returns:
         Text with all span elements removed and their inner content preserved.
+
     """
-    prev = None
-    while prev != text:
-        prev = text
-        text = re.sub(r"<span[^>]*>(.*?)</span>", r"\1", text, flags=re.DOTALL)
+    while True:
+        new_text = re.sub(r"<span[^>]*>(.*?)</span>", r"\1", text, flags=re.DOTALL)
+        if new_text == text:
+            return text
+        text = new_text
+
+
+# Emphasis markers. Each style has an asterisk variant and an underscore
+# variant, applied in that order; ``(?<!\\)`` skips backslash-escaped markers.
+_BOLD_ITALIC_PATTERNS = (
+    r"(?<!\\)\*{3}(.+?)(?<!\\)\*{3}",
+    r"(?<!\\)_{3}(.+?)(?<!\\)_{3}",
+)
+_BOLD_PATTERNS = (
+    r"(?<!\\)\*{2}(.+?)(?<!\\)\*{2}",
+    r"(?<!\\)__(.+?)(?<!\\)__",
+)
+# Italic also needs negative look-around, so that residual ** markers are never
+# matched, and word-boundary anchors, so that inside_words is left alone.
+_ITALIC_PATTERNS = (
+    r"(?<!\\)(?<!\*)\*(?!\*)(.+?)(?<!\\)(?<!\*)\*(?!\*)",
+    r"(?<!\w)(?<!\\)_(?!_)(.+?)(?<!\\)(?<!_)_(?!\w)",
+)
+
+
+def _style_markers(
+    text: str,
+    patterns: tuple[str, ...],
+    style: Callable[[str], str],
+) -> str:
+    """Apply *style* to the text captured by each emphasis pattern in turn.
+
+    Args:
+        text: Input text.
+        patterns: Regexes whose first capture group is the text to style.
+        style: Unicode mapping function applied to each captured group.
+
+    Returns:
+        Text with every matched marker pair replaced by styled Unicode.
+
+    """
+    for pattern in patterns:
+        text = re.sub(pattern, lambda m: style(m.group(1)), text)
     return text
 
 
 def _convert_bold_italic(text: str) -> str:
-    """Replace ``***text***`` (or ``___text___``) with bold-italic Unicode.
+    r"""Replace ``***text***`` (or ``___text___``) with bold-italic Unicode.
 
     Must run before :func:`_convert_bold` and :func:`_convert_italic` to
     prevent the triple markers from being consumed piecemeal.
@@ -133,21 +226,13 @@ def _convert_bold_italic(text: str) -> str:
 
     Returns:
         Text with bold-italic markers replaced.
+
     """
-    text = re.sub(
-        r"(?<!\\)\*{3}(.+?)(?<!\\)\*{3}",
-        lambda m: to_sans_bold_italic(m.group(1)),
-        text,
-    )
-    return re.sub(
-        r"(?<!\\)_{3}(.+?)(?<!\\)_{3}",
-        lambda m: to_sans_bold_italic(m.group(1)),
-        text,
-    )
+    return _style_markers(text, _BOLD_ITALIC_PATTERNS, to_sans_bold_italic)
 
 
 def _convert_bold(text: str) -> str:
-    """Replace ``**text**`` (or ``__text__``) with bold Unicode.
+    r"""Replace ``**text**`` (or ``__text__``) with bold Unicode.
 
     Backslash-escaped markers (``\\**``) are not matched.
 
@@ -156,21 +241,13 @@ def _convert_bold(text: str) -> str:
 
     Returns:
         Text with bold markers replaced.
+
     """
-    text = re.sub(
-        r"(?<!\\)\*{2}(.+?)(?<!\\)\*{2}",
-        lambda m: to_sans_bold(m.group(1)),
-        text,
-    )
-    return re.sub(
-        r"(?<!\\)__(.+?)(?<!\\)__",
-        lambda m: to_sans_bold(m.group(1)),
-        text,
-    )
+    return _style_markers(text, _BOLD_PATTERNS, to_sans_bold)
 
 
 def _convert_italic(text: str) -> str:
-    """Replace ``*text*`` or ``_text_`` with italic Unicode.
+    r"""Replace ``*text*`` or ``_text_`` with italic Unicode.
 
     Uses negative look-around to avoid matching asterisks that are part of
     bold (``**``) or bold-italic (``***``) markers already consumed by
@@ -182,19 +259,9 @@ def _convert_italic(text: str) -> str:
 
     Returns:
         Text with italic markers replaced.
+
     """
-    # *text* — negative look-around prevents matching residual ** markers or \* escapes
-    text = re.sub(
-        r"(?<!\\)(?<!\*)\*(?!\*)(.+?)(?<!\\)(?<!\*)\*(?!\*)",
-        lambda m: to_sans_italic(m.group(1)),
-        text,
-    )
-    # _text_ — word-boundary anchors prevent matching inside_words; skip \_ escapes
-    return re.sub(
-        r"(?<!\w)(?<!\\)_(?!_)(.+?)(?<!\\)(?<!_)_(?!\w)",
-        lambda m: to_sans_italic(m.group(1)),
-        text,
-    )
+    return _style_markers(text, _ITALIC_PATTERNS, to_sans_italic)
 
 
 def _convert_headers(text: str) -> str:
@@ -208,6 +275,7 @@ def _convert_headers(text: str) -> str:
 
     Returns:
         Text with headers replaced by styled plain text.
+
     """
     separator = "━" * 40
 
@@ -227,7 +295,7 @@ def _convert_headers(text: str) -> str:
         atx = re.match(r"^(#{1,6})\s+(.*)", line)
         if atx:
             level = len(atx.group(1))
-            title = atx.group(2).rstrip()
+            title = atx.group(2)
             if level == 1:
                 out.append(_fmt_h1(title))
             else:
@@ -269,6 +337,7 @@ def _strip_links(text: str, *, preserve: bool = False) -> str:
 
     Returns:
         Text with links handled according to *preserve*.
+
     """
     if preserve:
         return text
@@ -290,6 +359,7 @@ def _strip_images(text: str) -> str:
 
     Returns:
         Text with image syntax replaced by alt text.
+
     """
     # ![alt](url) → alt  (empty alt → removed)
     return re.sub(
@@ -311,6 +381,7 @@ def _convert_bullets(text: str) -> str:
 
     Returns:
         Text with list markers replaced.
+
     """
 
     def _bullet(m: re.Match[str]) -> str:
@@ -328,6 +399,7 @@ def _strip_blockquotes(text: str) -> str:
 
     Returns:
         Text with blockquote markers stripped from line beginnings.
+
     """
     return re.sub(r"^> ?", "", text, flags=re.MULTILINE)
 
@@ -341,28 +413,22 @@ def _clean_entities(text: str) -> str:
     Returns:
         Text with ``&gt;``, ``&lt;``, ``&amp;``, ``&nbsp;``, ``&quot;``
         replaced by their literal equivalents.
+
     """
-    replacements = {
-        "&gt;": ">",
-        "&lt;": "<",
-        "&amp;": "&",
-        "&nbsp;": " ",
-        "&quot;": '"',
-        "&apos;": "'",
-    }
-    for entity, char in replacements.items():
+    for entity, char in _HTML_ENTITIES.items():
         text = text.replace(entity, char)
     return text
 
 
 def _clean_escaped_chars(text: str) -> str:
-    """Remove Markdown backslash escapes (e.g. ``\\*`` → ``*``).
+    r"""Remove Markdown backslash escapes (e.g. ``\\*`` → ``*``).
 
     Args:
         text: Input text.
 
     Returns:
         Text with backslash escapes resolved.
+
     """
     return re.sub(r"\\([\\`*_{}\[\]()#+\-.!])", r"\1", text)
 
@@ -378,6 +444,7 @@ def _normalize_whitespace(text: str) -> str:
 
     Returns:
         Normalized text with a single trailing newline.
+
     """
     text = re.sub(r"\n{3,}", "\n\n", text)
     return text.strip() + "\n"
@@ -392,7 +459,7 @@ def convert(
     preserve_links: bool = False,
     monospace_code: bool = True,
 ) -> str:
-    """Convert Markdown text to LinkedIn-compatible Unicode plain text.
+    r"""Convert Markdown text to LinkedIn-compatible Unicode plain text.
 
     Bold (``**text**`` / ``__text__``), italic (``*text*`` / ``_text_``), and
     bold-italic (``***text***`` / ``___text___``) markers are replaced with
@@ -433,6 +500,7 @@ def convert(
 
         >>> convert("")
         ''
+
     """
     if not text or not text.strip():
         return ""
@@ -461,7 +529,7 @@ def convert_file(
     preserve_links: bool = False,
     monospace_code: bool = True,
 ) -> Path:
-    """Convert a Markdown file and write the result to a ``.txt`` file.
+    r"""Convert a Markdown file and write the result to a ``.txt`` file.
 
     Args:
         input_path: Path to the Markdown source file (``.md`` or any text
@@ -489,6 +557,7 @@ def convert_file(
         '𝗯𝗼𝗹𝗱 and 𝘪𝘵𝘢𝘭𝘪𝘤\\n'
         >>> os.unlink(tmp)
         ... os.unlink(str(out))
+
     """
     input_path = Path(input_path)
     if not input_path.exists():
@@ -499,11 +568,11 @@ def convert_file(
         output_path = input_path.with_suffix("").with_suffix(".linkedin.txt")
     output_path = Path(output_path)
 
-    md_text = input_path.read_text(encoding="utf-8")
+    md_text = input_path.read_text(encoding=_ENCODING)
     result = convert(
         md_text,
         preserve_links=preserve_links,
         monospace_code=monospace_code,
     )
-    output_path.write_text(result, encoding="utf-8")
+    output_path.write_text(result, encoding=_ENCODING)
     return output_path

{md2linkedin-0.2.2 → md2linkedin-0.3.0}/src/md2linkedin/_unicode.py

@@ -7,6 +7,7 @@ styling in plain-text environments like LinkedIn.
 
 from __future__ import annotations
 
+import string
 from typing import Literal
 
 __all__ = [
@@ -35,6 +36,42 @@ _MONOSPACE_LOWER = 0x1D68A  # 𝚊
 _MONOSPACE_DIGIT = 0x1D7F6  # 𝟶
 
 
+# ── Translation tables ─────────────────────────────────────────────────────────
+
+
+def _build_table(upper: int, lower: int, digit: int | None = None) -> dict[int, int]:
+    """Build a :meth:`str.translate` table for one Unicode style block.
+
+    Args:
+        upper: Codepoint of the styled ``A``.
+        lower: Codepoint of the styled ``a``.
+        digit: Codepoint of the styled ``0``, or ``None`` for styles whose
+            Unicode block has no digits (the italic blocks).
+
+    Returns:
+        A mapping from ASCII codepoint to styled codepoint. Characters absent
+        from the mapping are left unchanged by :meth:`str.translate`.
+
+    """
+    blocks = [(string.ascii_uppercase, upper), (string.ascii_lowercase, lower)]
+    if digit is not None:
+        blocks.append((string.digits, digit))
+    return {
+        ord(char): base + offset
+        for chars, base in blocks
+        for offset, char in enumerate(chars)
+    }
+
+
+_SANS_BOLD_TABLE = _build_table(_SANS_BOLD_UPPER, _SANS_BOLD_LOWER, _SANS_BOLD_DIGIT)
+_SANS_ITALIC_TABLE = _build_table(_SANS_ITALIC_UPPER, _SANS_ITALIC_LOWER)
+_SANS_BOLD_ITALIC_TABLE = _build_table(
+    _SANS_BOLD_ITALIC_UPPER,
+    _SANS_BOLD_ITALIC_LOWER,
+)
+_MONOSPACE_TABLE = _build_table(_MONOSPACE_UPPER, _MONOSPACE_LOWER, _MONOSPACE_DIGIT)
+
+
 # ── Public mapping functions ───────────────────────────────────────────────────
 
 
@@ -61,18 +98,9 @@ def to_sans_bold(text: str) -> str:
 
         >>> to_sans_bold("")
         ''
+
     """
-    out: list[str] = []
-    for c in text:
-        if "A" <= c <= "Z":
-            out.append(chr(_SANS_BOLD_UPPER + ord(c) - ord("A")))
-        elif "a" <= c <= "z":
-            out.append(chr(_SANS_BOLD_LOWER + ord(c) - ord("a")))
-        elif "0" <= c <= "9":
-            out.append(chr(_SANS_BOLD_DIGIT + ord(c) - ord("0")))
-        else:
-            out.append(c)
-    return "".join(out)
+    return text.translate(_SANS_BOLD_TABLE)
 
 
 def to_sans_italic(text: str) -> str:
@@ -98,16 +126,9 @@ def to_sans_italic(text: str) -> str:
 
         >>> to_sans_italic("")
         ''
+
     """
-    out: list[str] = []
-    for c in text:
-        if "A" <= c <= "Z":
-            out.append(chr(_SANS_ITALIC_UPPER + ord(c) - ord("A")))
-        elif "a" <= c <= "z":
-            out.append(chr(_SANS_ITALIC_LOWER + ord(c) - ord("a")))
-        else:
-            out.append(c)
-    return "".join(out)
+    return text.translate(_SANS_ITALIC_TABLE)
 
 
 def to_sans_bold_italic(text: str) -> str:
@@ -130,16 +151,9 @@ def to_sans_bold_italic(text: str) -> str:
 
         >>> to_sans_bold_italic("")
         ''
+
     """
-    out: list[str] = []
-    for c in text:
-        if "A" <= c <= "Z":
-            out.append(chr(_SANS_BOLD_ITALIC_UPPER + ord(c) - ord("A")))
-        elif "a" <= c <= "z":
-            out.append(chr(_SANS_BOLD_ITALIC_LOWER + ord(c) - ord("a")))
-        else:
-            out.append(c)
-    return "".join(out)
+    return text.translate(_SANS_BOLD_ITALIC_TABLE)
 
 
 def to_monospace(text: str) -> str:
@@ -165,18 +179,9 @@ def to_monospace(text: str) -> str:
 
         >>> to_monospace("")
         ''
+
     """
-    out: list[str] = []
-    for c in text:
-        if "A" <= c <= "Z":
-            out.append(chr(_MONOSPACE_UPPER + ord(c) - ord("A")))
-        elif "a" <= c <= "z":
-            out.append(chr(_MONOSPACE_LOWER + ord(c) - ord("a")))
-        elif "0" <= c <= "9":
-            out.append(chr(_MONOSPACE_DIGIT + ord(c) - ord("0")))
-        else:
-            out.append(c)
-    return "".join(out)
+    return text.translate(_MONOSPACE_TABLE)
 
 
 def apply_style(text: str, style: Literal["bold", "italic", "bold_italic"]) -> str:
@@ -205,6 +210,7 @@ def apply_style(text: str, style: Literal["bold", "italic", "bold_italic"]) -> s
 
         >>> apply_style("hello", "bold_italic")
         '𝙝𝙚𝙡𝙡𝙤'
+
     """
     if style == "bold":
         return to_sans_bold(text)