rxiv-maker 1.17.0__py3-none-any.whl → 1.18.1__py3-none-any.whl

rxiv_maker/utils/accent_character_map.py

@@ -0,0 +1,150 @@
+r"""LaTeX accent character to Unicode conversion map.
+
+This module provides centralized mapping of LaTeX accent commands to their
+Unicode equivalents. Used by both DOCX export and LaTeX processing to ensure
+consistent character handling across formats.
+
+Examples:
+    >>> clean_latex_accents("\\'e")
+    'é'
+    >>> clean_latex_accents("Calf{\\'e}")
+    'Café'
+"""
+
+from typing import Dict
+
+# LaTeX accent commands to Unicode character mapping
+# Handles both with and without backslashes (BibTeX parser may strip them)
+# Also handles variant forms where backslash is replaced with the literal character
+ACCENT_MAP: Dict[str, str] = {
+    # Acute accents (é, á, í, ó, ú) - use non-raw strings for single backslash
+    "\\'e": "é",
+    "{\\'e}": "é",
+    "{'e}": "é",
+    "{'é}": "é",
+    "\\'a": "á",
+    "{\\'a}": "á",
+    "{'a}": "á",
+    "{'á}": "á",
+    "\\'i": "í",
+    "{\\'i}": "í",
+    "{'i}": "í",
+    "{'í}": "í",
+    "'{\\i}": "í",  # Acute on dotless i
+    "\\'o": "ó",
+    "{\\'o}": "ó",
+    "{'o}": "ó",
+    "{'ó}": "ó",
+    "'{o}": "ó",  # Acute o (variant without backslash)
+    "\\'u": "ú",
+    "{\\'u}": "ú",
+    "{'u}": "ú",
+    "{'ú}": "ú",
+    # Uppercase acute accents
+    "\\'E": "É",
+    "{\\'E}": "É",
+    "{'E}": "É",
+    "\\'A": "Á",
+    "{\\'A}": "Á",
+    "{'A}": "Á",
+    "\\'I": "Í",
+    "{\\'I}": "Í",
+    "{'I}": "Í",
+    "'{\\I}": "Í",  # Acute on uppercase dotless I
+    "\\'O": "Ó",
+    "{\\'O}": "Ó",
+    "{'O}": "Ó",
+    "'{O}": "Ó",
+    "\\'U": "Ú",
+    "{\\'U}": "Ú",
+    "{'U}": "Ú",
+    # Umlaut/diaeresis (ë, ä, ï, ö, ü)
+    '\\"e': "ë",
+    '{\\"e}': "ë",
+    '{"e}': "ë",
+    '{"ë}': "ë",
+    '\\"a': "ä",
+    '{\\"a}': "ä",
+    '{"a}': "ä",
+    '{"ä}': "ä",
+    '\\"i': "ï",
+    '{\\"i}': "ï",
+    '{"i}': "ï",
+    '{"ï}': "ï",
+    '\\"o': "ö",
+    '{\\"o}': "ö",
+    '{"o}': "ö",
+    '{"ö}': "ö",
+    '\\"u': "ü",
+    '{\\"u}': "ü",
+    '{"u}': "ü",
+    '{"ü}': "ü",
+    # Grave accents (è, à)
+    "\\`e": "è",
+    "{\\`e}": "è",
+    "{`e}": "è",
+    "{`è}": "è",
+    "\\`a": "à",
+    "{\\`a}": "à",
+    "{`a}": "à",
+    "{`à}": "à",
+    # Circumflex (ê, â)
+    "\\^e": "ê",
+    "{\\^e}": "ê",
+    "{^e}": "ê",
+    "{^ê}": "ê",
+    "\\^a": "â",
+    "{\\^a}": "â",
+    "{^a}": "â",
+    "{^â}": "â",
+    # Tilde (ñ, ã, õ)
+    "\\~n": "ñ",
+    "{\\~n}": "ñ",
+    "{~n}": "ñ",
+    "{~ñ}": "ñ",
+    "~{n}": "ñ",
+    "\\~a": "ã",
+    "{\\~a}": "ã",
+    "{~a}": "ã",
+    "~{a}": "ã",  # Tilde on a (variant)
+    "{~ã}": "ã",
+    "\\~o": "õ",
+    "{\\~o}": "õ",
+    "{~o}": "õ",
+    "~{o}": "õ",  # Tilde on o (variant)
+    "{~õ}": "õ",
+    # Uppercase tilde
+    "\\~N": "Ñ",
+    "{\\~N}": "Ñ",
+    "~{N}": "Ñ",
+    "\\~A": "Ã",
+    "{\\~A}": "Ã",
+    "~{A}": "Ã",
+    "\\~O": "Õ",
+    "{\\~O}": "Õ",
+    "~{O}": "Õ",
+    # Cedilla (ç)
+    "\\c{c}": "ç",
+    "{\\c{c}}": "ç",
+    "{\\c{ç}}": "ç",
+}
+
+
+def clean_latex_accents(text: str) -> str:
+    r"""Convert LaTeX accent commands to Unicode characters.
+
+    Args:
+        text: Text containing LaTeX accent commands
+
+    Returns:
+        Text with accent commands converted to Unicode
+
+    Examples:
+        >>> clean_latex_accents("Calf{\\'e}")
+        'Café'
+        >>> clean_latex_accents("Se\\~nor")
+        'Señor'
+    """
+    for latex_cmd, unicode_char in ACCENT_MAP.items():
+        text = text.replace(latex_cmd, unicode_char)
+    return text

rxiv_maker/utils/author_affiliation_processor.py

@@ -0,0 +1,128 @@
+"""Author and affiliation processing utilities for manuscript processing.
+
+This module provides centralized author and affiliation mapping logic used by both
+DOCX export and LaTeX/PDF generation to ensure consistent handling across formats.
+
+The processor handles:
+- Building affiliation shortname → number mappings in order of first appearance
+- Looking up full affiliation details from metadata
+- Categorizing authors (co-first, corresponding)
+- Mapping author affiliations to sequential numbers
+
+Examples:
+    >>> processor = AuthorAffiliationProcessor()
+    >>> metadata = {
+    ...     "authors": [{"name": "Alice", "affiliations": ["MIT"], "co_first_author": True}],
+    ...     "affiliations": [{"shortname": "MIT", "full_name": "MIT", "location": "Cambridge"}]
+    ... }
+    >>> result = processor.process(metadata)
+    >>> result["affiliation_map"]
+    {'MIT': 1}
+    >>> result["cofirst_authors"]
+    [{'name': 'Alice', 'affiliations': ['MIT'], 'co_first_author': True}]
+"""
+
+from typing import Any, Dict, List
+
+
+class AuthorAffiliationProcessor:
+    """Process author and affiliation metadata for manuscript generation."""
+
+    def process(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Process author and affiliation metadata.
+
+        Extracts and organizes author/affiliation data for use by format-specific
+        renderers (DOCX, LaTeX, etc.).
+
+        Args:
+            metadata: YAML metadata containing authors and affiliations
+
+        Returns:
+            Dict containing:
+                - affiliation_map: Dict[str, int] mapping shortnames to numbers
+                - ordered_affiliations: List[Tuple[int, str, str]] of (number, shortname, full_text)
+                - authors: List[Dict] of author metadata
+                - cofirst_authors: List[Dict] of co-first authors
+                - corresponding_authors: List[Dict] of corresponding authors
+
+        Examples:
+            >>> processor = AuthorAffiliationProcessor()
+            >>> metadata = {
+            ...     "authors": [
+            ...         {"name": "Alice", "affiliations": ["MIT"], "co_first_author": True},
+            ...         {"name": "Bob", "affiliations": ["MIT", "Harvard"], "corresponding_author": True}
+            ...     ],
+            ...     "affiliations": [
+            ...         {"shortname": "MIT", "full_name": "Massachusetts Institute of Technology", "location": "Cambridge, MA"},
+            ...         {"shortname": "Harvard", "full_name": "Harvard University", "location": "Cambridge, MA"}
+            ...     ]
+            ... }
+            >>> result = processor.process(metadata)
+            >>> result["affiliation_map"]
+            {'MIT': 1, 'Harvard': 2}
+            >>> len(result["cofirst_authors"])
+            1
+            >>> len(result["corresponding_authors"])
+            1
+        """
+        authors = metadata.get("authors", [])
+        affiliations = metadata.get("affiliations", [])
+
+        # Build affiliation details lookup
+        affiliation_details = {a.get("shortname"): a for a in affiliations if isinstance(a, dict)}
+
+        # Build affiliation map in order of first appearance
+        affiliation_map = {}
+        ordered_affiliations = []
+
+        for author in authors:
+            if isinstance(author, dict):
+                author_affiliations = author.get("affiliations", [])
+                for affil_shortname in author_affiliations:
+                    if affil_shortname not in affiliation_map:
+                        # Assign next number
+                        affil_num = len(affiliation_map) + 1
+                        affiliation_map[affil_shortname] = affil_num
+
+                        # Look up full details
+                        affil_info = affiliation_details.get(affil_shortname, {})
+                        full_name = affil_info.get("full_name", affil_shortname)
+                        location = affil_info.get("location", "")
+
+                        # Format: "Full Name, Location" or just "Full Name"
+                        full_text = f"{full_name}, {location}" if location else full_name
+
+                        ordered_affiliations.append((affil_num, affil_shortname, full_text))
+
+        # Categorize authors
+        cofirst_authors = [a for a in authors if isinstance(a, dict) and a.get("co_first_author", False)]
+        corresponding_authors = [a for a in authors if isinstance(a, dict) and a.get("corresponding_author", False)]
+
+        return {
+            "affiliation_map": affiliation_map,
+            "ordered_affiliations": ordered_affiliations,
+            "authors": authors,
+            "cofirst_authors": cofirst_authors,
+            "corresponding_authors": corresponding_authors,
+        }
+
+    def get_author_affiliation_numbers(self, author: Dict[str, Any], affiliation_map: Dict[str, int]) -> List[int]:
+        """Get sorted affiliation numbers for an author.
+
+        Args:
+            author: Author metadata dict
+            affiliation_map: Mapping from shortname to number
+
+        Returns:
+            Sorted list of affiliation numbers for this author
+
+        Examples:
+            >>> processor = AuthorAffiliationProcessor()
+            >>> author = {"name": "Alice", "affiliations": ["Harvard", "MIT"]}
+            >>> affil_map = {"MIT": 1, "Harvard": 2}
+            >>> processor.get_author_affiliation_numbers(author, affil_map)
+            [1, 2]
+        """
+        author_affiliations = author.get("affiliations", [])
+        affil_numbers = [affiliation_map[a] for a in author_affiliations if a in affiliation_map]
+        return sorted(affil_numbers)

rxiv_maker/utils/citation_range_formatter.py

@@ -0,0 +1,118 @@
+"""Citation range formatting utilities for manuscript processing.
+
+This module provides utilities to format consecutive citation numbers as ranges
+(e.g., [1, 2, 3] → [1-3]). Used by DOCX export and potentially LaTeX processing
+to create compact, readable citation references.
+
+Examples:
+    >>> format_number_list([1, 2, 3, 5, 6, 8])
+    '[1-3, 5-6, 8]'
+    >>> format_citation_ranges("text [1][2][3] more")
+    'text [1-3] more'
+"""
+
+import re
+from typing import List
+
+
+def format_number_list(numbers: List[int]) -> str:
+    """Format a list of citation numbers as ranges.
+
+    Consecutive numbers are combined into ranges with hyphens.
+    Single numbers and non-consecutive numbers are separated by commas.
+
+    Args:
+        numbers: List of citation numbers
+
+    Returns:
+        Formatted string with ranges
+
+    Examples:
+        >>> format_number_list([1, 2, 3, 5, 6, 8])
+        '[1-3, 5-6, 8]'
+        >>> format_number_list([15, 16])
+        '[15-16]'
+        >>> format_number_list([1, 3, 5])
+        '[1, 3, 5]'
+        >>> format_number_list([])
+        '[]'
+    """
+    if not numbers:
+        return "[]"
+
+    # Sort and deduplicate numbers
+    sorted_nums = sorted(set(numbers))
+
+    # Build ranges
+    ranges = []
+    start = sorted_nums[0]
+    end = sorted_nums[0]
+
+    for num in sorted_nums[1:]:
+        if num == end + 1:
+            # Continue current range
+            end = num
+        else:
+            # End current range and start new one
+            if start == end:
+                # Single number
+                ranges.append(str(start))
+            else:
+                # Range (including 2 consecutive numbers like 15-16)
+                ranges.append(f"{start}-{end}")
+            start = num
+            end = num
+
+    # Add final range
+    if start == end:
+        # Single number
+        ranges.append(str(start))
+    else:
+        # Range (including 2 consecutive numbers like 15-16)
+        ranges.append(f"{start}-{end}")
+
+    return f"[{', '.join(ranges)}]"
+
+
+def format_citation_ranges(text: str) -> str:
+    """Format consecutive citations as ranges.
+
+    Converts patterns like [1][2][3] to [1-3], [15][16] to [15-16], etc.
+    Also formats comma-separated lists like [1, 2, 3] to [1-3].
+
+    Args:
+        text: Text with numbered citations
+
+    Returns:
+        Text with consecutive citations formatted as ranges
+
+    Examples:
+        >>> format_citation_ranges("text [1][2][3] more")
+        'text [1-3] more'
+        >>> format_citation_ranges("text [1, 2, 3] more")
+        'text [1-3] more'
+        >>> format_citation_ranges("text [1][3][4] more")
+        'text [1][3-4] more'
+        >>> format_citation_ranges("text [1] [2] [3] more")
+        'text [1-3] more'
+    """
+
+    # Pattern 1: Handle adjacent bracketed citations [1][2][3] or [1] [2] [3]
+    def combine_adjacent(match_obj):
+        # Extract all numbers from consecutive brackets (allowing spaces between)
+        numbers = [int(n) for n in re.findall(r"\[(\d+)\]", match_obj.group(0))]
+        return format_number_list(numbers)
+
+    # Find sequences of adjacent bracketed numbers (with optional spaces between)
+    text = re.sub(r"(?:\[\d+\]\s*){2,}", combine_adjacent, text)
+
+    # Pattern 2: Handle comma-separated citations within single brackets [1, 2, 3]
+    def combine_comma_separated(match_obj):
+        # Extract all numbers from comma-separated list
+        numbers_str = match_obj.group(1)
+        numbers = [int(n.strip()) for n in numbers_str.split(",")]
+        return format_number_list(numbers)
+
+    text = re.sub(r"\[([\d,\s]+)\]", combine_comma_separated, text)
+
+    return text

rxiv_maker/utils/comment_filter.py

@@ -0,0 +1,46 @@
+"""Comment filtering utilities for manuscript processing.
+
+This module provides utilities to identify and filter metadata comments
+from manuscript content. Used by both DOCX export and potentially LaTeX
+processing to handle comment blocks consistently.
+
+Examples:
+    >>> is_metadata_comment("Note: this is a metadata comment")
+    True
+    >>> is_metadata_comment("TODO: fix this")
+    False
+"""
+
+
+def is_metadata_comment(comment_text: str) -> bool:
+    """Check if a comment is metadata/informational and should be skipped.
+
+    Metadata comments are those that start with common prefixes like
+    "Note:", "Comment:", etc. These are typically informational and
+    should be filtered out during processing.
+
+    Args:
+        comment_text: The comment text to check
+
+    Returns:
+        True if comment should be skipped (is metadata), False if it should be included
+
+    Examples:
+        >>> is_metadata_comment("Note: remember to update this")
+        True
+        >>> is_metadata_comment("comment this section is WIP")
+        True
+        >>> is_metadata_comment("TODO: fix the bug")
+        False
+        >>> is_metadata_comment("")
+        True
+    """
+    if not comment_text:
+        return True
+
+    # Normalize to lowercase for case-insensitive matching
+    normalized = comment_text.lower().strip()
+
+    # Skip comments that start with common metadata keywords
+    metadata_prefixes = ["note:", "note ", "comment:", "comment "]
+    return any(normalized.startswith(prefix) for prefix in metadata_prefixes)

rxiv_maker/utils/docx_helpers.py

@@ -210,123 +210,10 @@ def clean_latex_commands(text: str) -> str:
     text = html.unescape(text)
 
     # Convert LaTeX accent commands to Unicode
-    # Handle both with and without backslashes (BibTeX parser may strip them)
-    # Also handle variant forms where backslash is replaced with the literal character
-    accent_map = {
-        # Acute accents (é, á, í, ó, ú) - use non-raw strings for single backslash
-        "\\'e": "é",
-        "{\\'e}": "é",
-        "{'e}": "é",
-        "{'é}": "é",
-        "\\'a": "á",
-        "{\\'a}": "á",
-        "{'a}": "á",
-        "{'á}": "á",
-        "\\'i": "í",
-        "{\\'i}": "í",
-        "{'i}": "í",
-        "{'í}": "í",
-        "'{\\i}": "í",  # Acute on dotless i
-        "\\'o": "ó",
-        "{\\'o}": "ó",
-        "{'o}": "ó",
-        "{'ó}": "ó",
-        "'{o}": "ó",  # Acute o (variant without backslash)
-        "\\'u": "ú",
-        "{\\'u}": "ú",
-        "{'u}": "ú",
-        "{'ú}": "ú",
-        # Uppercase acute accents
-        "\\'E": "É",
-        "{\\'E}": "É",
-        "{'E}": "É",
-        "\\'A": "Á",
-        "{\\'A}": "Á",
-        "{'A}": "Á",
-        "\\'I": "Í",
-        "{\\'I}": "Í",
-        "{'I}": "Í",
-        "'{\\I}": "Í",  # Acute on uppercase dotless I
-        "\\'O": "Ó",
-        "{\\'O}": "Ó",
-        "{'O}": "Ó",
-        "'{O}": "Ó",
-        "\\'U": "Ú",
-        "{\\'U}": "Ú",
-        "{'U}": "Ú",
-        # Umlaut/diaeresis (ë, ä, ï, ö, ü)
-        '\\"e': "ë",
-        '{\\"e}': "ë",
-        '{"e}': "ë",
-        '{"ë}': "ë",
-        '\\"a': "ä",
-        '{\\"a}': "ä",
-        '{"a}': "ä",
-        '{"ä}': "ä",
-        '\\"i': "ï",
-        '{\\"i}': "ï",
-        '{"i}': "ï",
-        '{"ï}': "ï",
-        '\\"o': "ö",
-        '{\\"o}': "ö",
-        '{"o}': "ö",
-        '{"ö}': "ö",
-        '\\"u': "ü",
-        '{\\"u}': "ü",
-        '{"u}': "ü",
-        '{"ü}': "ü",
-        # Grave accents (è, à)
-        "\\`e": "è",
-        "{\\`e}": "è",
-        "{`e}": "è",
-        "{`è}": "è",
-        "\\`a": "à",
-        "{\\`a}": "à",
-        "{`a}": "à",
-        "{`à}": "à",
-        # Circumflex (ê, â)
-        "\\^e": "ê",
-        "{\\^e}": "ê",
-        "{^e}": "ê",
-        "{^ê}": "ê",
-        "\\^a": "â",
-        "{\\^a}": "â",
-        "{^a}": "â",
-        "{^â}": "â",
-        # Tilde (ñ, ã, õ)
-        "\\~n": "ñ",
-        "{\\~n}": "ñ",
-        "{~n}": "ñ",
-        "{~ñ}": "ñ",
-        "~{n}": "ñ",
-        "\\~a": "ã",
-        "{\\~a}": "ã",
-        "{~a}": "ã",
-        "~{a}": "ã",  # Tilde on a (variant)
-        "{~ã}": "ã",
-        "\\~o": "õ",
-        "{\\~o}": "õ",
-        "{~o}": "õ",
-        "~{o}": "õ",  # Tilde on o (variant)
-        "{~õ}": "õ",
-        # Uppercase tilde
-        "\\~N": "Ñ",
-        "{\\~N}": "Ñ",
-        "~{N}": "Ñ",
-        "\\~A": "Ã",
-        "{\\~A}": "Ã",
-        "~{A}": "Ã",
-        "\\~O": "Õ",
-        "{\\~O}": "Õ",
-        "~{O}": "Õ",
-        # Cedilla (ç)
-        "\\c{c}": "ç",
-        "{\\c{c}}": "ç",
-        "{\\c{ç}}": "ç",
-    }
-
-    for latex_cmd, unicode_char in accent_map.items():
-        text = text.replace(latex_cmd, unicode_char)
+    # Uses centralized accent map from accent_character_map module
+    from .accent_character_map import clean_latex_accents
+
+    text = clean_latex_accents(text)
 
     # Remove common formatting commands but keep their content
     text = re.sub(r"\\textbf\{([^}]+)\}", r"\1", text)