rxiv-maker 1.18.5__py3-none-any.whl → 1.19.0__py3-none-any.whl

rxiv_maker/__version__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "1.18.5"
+__version__ = "1.19.0"

rxiv_maker/cli/commands/__init__.py

@@ -2,6 +2,7 @@
 
 from .arxiv import arxiv
 from .bibliography import bibliography
+from .biorxiv import biorxiv
 from .build import build as pdf
 from .cache_management import cache_group as cache
 from .changelog import changelog
@@ -29,6 +30,7 @@ from .version import version
 __all__ = [
     "arxiv",
     "bibliography",
+    "biorxiv",
     "cache",
     "changelog",
     "config",

rxiv_maker/cli/commands/biorxiv.py

@@ -0,0 +1,51 @@
+"""bioRxiv submission package generation command."""
+
+import rich_click as click
+
+from ..framework.workflow_commands import BioRxivCommand
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("manuscript_path", type=click.Path(exists=True, file_okay=False), required=False)
+@click.option("--output-dir", "-o", default="output", help="Output directory for generated files")
+@click.option(
+    "--biorxiv-dir",
+    "-b",
+    help="Custom bioRxiv submission directory (default: output/biorxiv_submission)",
+)
+@click.option(
+    "--zip-filename",
+    "-z",
+    help="Custom ZIP filename (default: {manuscript}_biorxiv.zip)",
+)
+@click.option(
+    "--no-zip",
+    is_flag=True,
+    help="Don't create ZIP file (only create submission directory)",
+)
+@click.pass_context
+def biorxiv(ctx, manuscript_path, output_dir, biorxiv_dir, zip_filename, no_zip):
+    r"""Generate bioRxiv submission package.
+
+    Creates a complete submission package including:
+    - bioRxiv author template (TSV file)
+    - Manuscript PDF
+    - Source files (TeX, figures, bibliography)
+    - ZIP file for upload
+
+    \b
+    Example:
+        rxiv biorxiv                           # Full package with ZIP
+        rxiv biorxiv --no-zip                  # Package without ZIP
+        rxiv biorxiv -b custom_dir             # Custom submission directory
+        rxiv biorxiv -z my_submission.zip      # Custom ZIP filename
+    """
+    command = BioRxivCommand()
+    return command.run(
+        ctx,
+        manuscript_path=manuscript_path,
+        output_dir=output_dir,
+        biorxiv_dir=biorxiv_dir,
+        zip_filename=zip_filename,
+        no_zip=no_zip,
+    )

rxiv_maker/cli/framework/base.py

@@ -162,6 +162,97 @@ class BaseCommand(ABC):
         if suggestion:
             self.console.print(f"💡 {suggestion}", style="yellow")
 
+    def _clear_output_directory(self) -> None:
+        """Clear and recreate the output directory.
+
+        Raises:
+            CommandExecutionError: If path_manager is not initialized
+        """
+        import shutil
+
+        if not self.path_manager:
+            raise CommandExecutionError("Path manager not initialized")
+
+        if self.path_manager.output_dir.exists():
+            shutil.rmtree(self.path_manager.output_dir)
+        self.path_manager.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def _ensure_pdf_built(self, progress_task=None, quiet: bool = True) -> None:
+        """Ensure PDF is built, building it if necessary.
+
+        Args:
+            progress_task: Optional progress task to update
+            quiet: Whether to suppress build output
+
+        Raises:
+            CommandExecutionError: If path_manager is not initialized or build fails
+        """
+        from ...engines.operations.build_manager import BuildManager
+
+        if not self.path_manager:
+            raise CommandExecutionError("Path manager not initialized")
+
+        pdf_filename = f"{self.path_manager.manuscript_name}.pdf"
+        pdf_path = self.path_manager.output_dir / pdf_filename
+
+        if not pdf_path.exists():
+            if progress_task:
+                progress_task.update(description="Building PDF first...")
+
+            build_manager = BuildManager(
+                manuscript_path=str(self.path_manager.manuscript_path),
+                output_dir=str(self.path_manager.output_dir),
+                verbose=self.verbose,
+                quiet=quiet,
+            )
+
+            try:
+                success = build_manager.build()
+                if not success:
+                    raise CommandExecutionError("PDF build failed")
+            except Exception as e:
+                raise CommandExecutionError(f"Failed to build PDF: {e}") from e
+
+    def _set_submission_defaults(
+        self,
+        submission_type: str,
+        submission_dir: Optional[str] = None,
+        zip_filename: Optional[str] = None,
+    ) -> tuple[str, str]:
+        """Set default paths for submission directories and ZIP files.
+
+        Args:
+            submission_type: Type of submission ("arxiv" or "biorxiv")
+            submission_dir: Custom submission directory path (optional)
+            zip_filename: Custom ZIP filename (optional)
+
+        Returns:
+            Tuple of (submission_dir, zip_filename) with defaults applied
+
+        Raises:
+            CommandExecutionError: If path_manager is not initialized
+        """
+        from pathlib import Path
+
+        if not self.path_manager:
+            raise CommandExecutionError("Path manager not initialized")
+
+        manuscript_output_dir = str(self.path_manager.output_dir)
+
+        # Set default submission directory
+        if submission_dir is None:
+            submission_dir = str(Path(manuscript_output_dir) / f"{submission_type}_submission")
+
+        # Set default ZIP filename
+        if zip_filename is None:
+            manuscript_name = self.path_manager.manuscript_name
+            if submission_type == "arxiv":
+                zip_filename = str(Path(manuscript_output_dir) / "for_arxiv.zip")
+            else:
+                zip_filename = str(Path(manuscript_output_dir) / f"{manuscript_name}_{submission_type}.zip")
+
+        return submission_dir, zip_filename
+
     @abstractmethod
     def execute_operation(self, **kwargs) -> Any:
         """Execute the main command operation.

rxiv_maker/cli/framework/workflow_commands.py

@@ -366,46 +366,25 @@ class ArxivCommand(BaseCommand):
             no_zip: Don't create zip file
         """
         import sys
-        from pathlib import Path
 
-        from rxiv_maker.engines.operations.build_manager import BuildManager
         from rxiv_maker.engines.operations.prepare_arxiv import main as prepare_arxiv_main
 
-        if self.path_manager is None:
-            raise CommandExecutionError("Path manager not initialized")
-
+        # Set defaults using shared helper
+        arxiv_dir, zip_filename = self._set_submission_defaults("arxiv", arxiv_dir, zip_filename)
         manuscript_output_dir = str(self.path_manager.output_dir)
 
-        # Set defaults using PathManager
-        if arxiv_dir is None:
-            arxiv_dir = str(Path(manuscript_output_dir) / "arxiv_submission")
-        if zip_filename is None:
-            zip_filename = str(Path(manuscript_output_dir) / "for_arxiv.zip")
-
         with self.create_progress() as progress:
-            # Clear output directory first (similar to PDF command)
+            # Clear output directory using shared helper
             task = progress.add_task("Clearing output directory...", total=None)
-            if self.path_manager.output_dir.exists():
-                shutil.rmtree(self.path_manager.output_dir)
-            self.path_manager.output_dir.mkdir(parents=True, exist_ok=True)
+            self._clear_output_directory()
 
-            # First, ensure PDF is built
+            # Ensure PDF is built using shared helper
             progress.update(task, description="Checking PDF exists...")
-            pdf_filename = f"{self.path_manager.manuscript_name}.pdf"
-            pdf_path = self.path_manager.output_dir / pdf_filename
-
-            if not pdf_path.exists():
-                progress.update(task, description="Building PDF first...")
-                build_manager = BuildManager(
-                    manuscript_path=str(self.path_manager.manuscript_path),
-                    output_dir=str(self.path_manager.output_dir),
-                    verbose=self.verbose,
-                    quiet=False,
-                )
-                success = build_manager.run()
-                if not success:
-                    self.error_message("PDF build failed. Cannot prepare arXiv package.")
-                    raise CommandExecutionError("PDF build failed")
+            try:
+                self._ensure_pdf_built(progress_task=task, quiet=False)
+            except CommandExecutionError:
+                self.error_message("PDF build failed. Cannot prepare arXiv package.")
+                raise
 
             # Prepare arXiv package
             progress.update(task, description="Preparing arXiv package...")
@@ -524,6 +503,95 @@ class ArxivCommand(BaseCommand):
         return year, first_author
 
 
+class BioRxivCommand(BaseCommand):
+    """BioRxiv command implementation for generating submission package."""
+
+    def execute_operation(
+        self,
+        output_dir: str = "output",
+        biorxiv_dir: Optional[str] = None,
+        zip_filename: Optional[str] = None,
+        no_zip: bool = False,
+    ) -> None:
+        """Execute bioRxiv submission package preparation.
+
+        Args:
+            output_dir: Output directory for generated files
+            biorxiv_dir: Custom bioRxiv submission directory path
+            zip_filename: Custom zip filename
+            no_zip: Don't create zip file
+        """
+        from pathlib import Path
+
+        from ...engines.operations.prepare_biorxiv import (
+            BioRxivAuthorError,
+            create_biorxiv_zip,
+            generate_biorxiv_author_tsv,
+            prepare_biorxiv_package,
+        )
+
+        # Set defaults using shared helper
+        biorxiv_dir, zip_filename = self._set_submission_defaults("biorxiv", biorxiv_dir, zip_filename)
+
+        with self.create_progress() as progress:
+            # Clear output directory using shared helper
+            task = progress.add_task("Clearing output directory...", total=None)
+            self._clear_output_directory()
+
+            # Ensure PDF is built using shared helper
+            progress.update(task, description="Checking PDF exists...")
+            self._ensure_pdf_built(progress_task=task, quiet=True)
+
+            # Generate bioRxiv author template TSV
+            progress.update(task, description="Generating bioRxiv author template...")
+            output_path = self.path_manager.output_dir
+            tsv_file = output_path / "biorxiv_authors.tsv"
+
+            try:
+                generate_biorxiv_author_tsv(
+                    config_path=self.path_manager.get_config_file_path(),
+                    output_path=tsv_file,
+                )
+            except BioRxivAuthorError as e:
+                progress.update(task, completed=True)
+                raise CommandExecutionError(f"Failed to generate bioRxiv template: {e}") from e
+
+            # Prepare bioRxiv submission package
+            progress.update(task, description="Preparing bioRxiv submission package...")
+            try:
+                biorxiv_path = prepare_biorxiv_package(
+                    manuscript_path=self.path_manager.manuscript_path,
+                    output_dir=self.path_manager.output_dir,
+                    biorxiv_dir=Path(biorxiv_dir),
+                )
+            except Exception as e:
+                progress.update(task, completed=True)
+                raise CommandExecutionError(f"Failed to prepare bioRxiv package: {e}") from e
+
+            # Create ZIP file if requested
+            zip_path = None
+            if not no_zip:
+                progress.update(task, description="Creating ZIP package...")
+                try:
+                    zip_path = create_biorxiv_zip(
+                        biorxiv_path=biorxiv_path,
+                        zip_filename=zip_filename,
+                        manuscript_path=self.path_manager.manuscript_path,
+                    )
+                except Exception as e:
+                    progress.update(task, completed=True)
+                    raise CommandExecutionError(f"Failed to create ZIP: {e}") from e
+
+            progress.update(task, completed=True)
+
+            # Show success message
+            self.console.print("\n[green]✅ bioRxiv submission package ready![/green]")
+            self.console.print(f"   📁 Package directory: {biorxiv_path}")
+            if zip_path:
+                self.console.print(f"   📦 ZIP file: {zip_path}")
+            self.console.print("\n📤 Upload to: https://submit.biorxiv.org/")
+
+
 class TrackChangesCommand(BaseCommand):
     """Track changes command implementation using the framework."""
 

rxiv_maker/cli/main.py

@@ -60,7 +60,7 @@ click.rich_click.COMMAND_GROUPS = {
         },
         {
             "name": "Workflow Commands",
-            "commands": ["get-rxiv-preprint", "arxiv", "track-changes", "setup"],
+            "commands": ["get-rxiv-preprint", "arxiv", "biorxiv", "track-changes", "setup"],
         },
         {
             "name": "Configuration",
@@ -252,6 +252,7 @@ main.add_command(commands.docx)
 main.add_command(commands.figures)
 main.add_command(commands.get_rxiv_preprint, name="get-rxiv-preprint")
 main.add_command(commands.arxiv)
+main.add_command(commands.biorxiv)
 main.add_command(commands.init)
 main.add_command(commands.bibliography)
 main.add_command(commands.track_changes)

rxiv_maker/engines/operations/prepare_biorxiv.py

@@ -0,0 +1,401 @@
+"""Prepare bioRxiv author submission template (TSV format).
+
+This module generates a tab-separated values (TSV) file containing author information
+formatted for bioRxiv submission system upload.
+"""
+
+import csv
+import html.entities
+import logging
+import shutil
+import zipfile
+from pathlib import Path
+
+from ...core.managers.config_manager import ConfigManager
+from ...utils.author_name_formatter import parse_author_name
+from ...utils.email_encoder import decode_email
+
+logger = logging.getLogger(__name__)
+
+
+def encode_html_entities(text: str) -> str:
+    """Convert Unicode characters to HTML entities for bioRxiv submission.
+
+    bioRxiv's TSV upload requires special characters to be encoded as HTML entities.
+    For example, "António" becomes "António", "Åbo" becomes "Åbo".
+
+    Args:
+        text: Text that may contain Unicode characters
+
+    Returns:
+        Text with Unicode characters converted to HTML entities
+        (e.g., "António" -> "António", "Åbo" -> "Åbo")
+
+    Examples:
+        >>> encode_html_entities("António")
+        'António'
+        >>> encode_html_entities("Åbo")
+        'Åbo'
+        >>> encode_html_entities("José García")
+        'José García'
+    """
+    if not text:
+        return text
+
+    # Build reverse mapping: Unicode character -> HTML entity name
+    char_to_entity = {}
+    for entity_name, codepoint in html.entities.name2codepoint.items():
+        char = chr(codepoint)
+        # Skip basic ASCII characters and use named entities for special chars
+        if ord(char) > 127:
+            char_to_entity[char] = f"&{entity_name};"
+
+    # Convert each character to HTML entity if it has one
+    result = []
+    for char in text:
+        if char in char_to_entity:
+            result.append(char_to_entity[char])
+        else:
+            result.append(char)
+
+    return "".join(result)
+
+
+class BioRxivAuthorError(Exception):
+    """Exception raised for bioRxiv author template generation errors."""
+
+    pass
+
+
+def validate_author_data(authors: list[dict]) -> None:
+    """Validate author data for bioRxiv submission requirements.
+
+    Args:
+        authors: List of author dictionaries from config
+
+    Raises:
+        BioRxivAuthorError: If validation fails
+    """
+    if not authors:
+        raise BioRxivAuthorError("No authors found in configuration")
+
+    # Count corresponding authors
+    corresponding_count = sum(1 for author in authors if author.get("corresponding_author", False))
+
+    if corresponding_count == 0:
+        raise BioRxivAuthorError(
+            "No corresponding author found. "
+            "Exactly one author must be marked with 'corresponding_author: true' in 00_CONFIG.yml"
+        )
+
+    if corresponding_count > 1:
+        corresponding_names = [
+            author.get("name", "Unknown") for author in authors if author.get("corresponding_author", False)
+        ]
+        raise BioRxivAuthorError(
+            f"Multiple corresponding authors found: {', '.join(corresponding_names)}. "
+            "Only one author should be marked with 'corresponding_author: true' in 00_CONFIG.yml"
+        )
+
+    # Validate each author has a name
+    for i, author in enumerate(authors):
+        if not author.get("name"):
+            raise BioRxivAuthorError(f"Author at index {i} is missing the 'name' field")
+
+
+def format_author_row(author_data: dict, affiliation_map: dict) -> list[str]:
+    """Format a single author's data as a bioRxiv TSV row.
+
+    Args:
+        author_data: Author dictionary with processed data
+        affiliation_map: Dictionary mapping affiliation shortnames to full data
+
+    Returns:
+        List of column values in bioRxiv order:
+        Email, Institution, First Name, Middle Name(s)/Initial(s), Last Name, Suffix,
+        Corresponding Author, Home Page URL, Collaborative Group/Consortium, ORCiD
+    """
+    # Email (decoded from email64)
+    email = author_data.get("email", "")
+
+    # Institution (first affiliation's full_name) - encode HTML entities for bioRxiv
+    institution = ""
+    affiliations = author_data.get("affiliations", [])
+    if affiliations and affiliations[0] in affiliation_map:
+        institution = encode_html_entities(affiliation_map[affiliations[0]].get("full_name", ""))
+
+    # Parse name into components and encode HTML entities for bioRxiv
+    name_str = author_data.get("name", "")
+    name_parts = parse_author_name(name_str)
+
+    first_name = encode_html_entities(name_parts.get("first", ""))
+    middle_name = encode_html_entities(name_parts.get("middle", ""))
+    last_name = encode_html_entities(name_parts.get("last", ""))
+    suffix = encode_html_entities(name_parts.get("suffix", ""))
+
+    # Corresponding author (any text for Yes, empty string for No)
+    corresponding = "Yes" if author_data.get("corresponding_author", False) else ""
+
+    # Home Page URL (empty - user preference)
+    home_page_url = ""
+
+    # Collaborative Group/Consortium (empty)
+    collaborative_group = ""
+
+    # ORCiD (if present)
+    orcid = author_data.get("orcid", "")
+
+    return [
+        email,
+        institution,
+        first_name,
+        middle_name,
+        last_name,
+        suffix,
+        corresponding,
+        home_page_url,
+        collaborative_group,
+        orcid,
+    ]
+
+
+def generate_biorxiv_author_tsv(config_path: Path, output_path: Path) -> Path:
+    """Generate bioRxiv author submission template (TSV format).
+
+    Args:
+        config_path: Path to the manuscript 00_CONFIG.yml file
+        output_path: Path where the TSV file should be written
+
+    Returns:
+        Path to the generated TSV file
+
+    Raises:
+        BioRxivAuthorError: If author data is invalid or missing
+        FileNotFoundError: If config file doesn't exist
+    """
+    if not config_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+    # Load manuscript configuration
+    config_manager = ConfigManager(config_path.parent)
+    config = config_manager.load_config(config_path)
+
+    # Extract authors and affiliations
+    authors = config.get("authors", [])
+    affiliations = config.get("affiliations", [])
+
+    # Handle multiple corresponding authors: keep only the last one
+    corresponding_indices = [i for i, author in enumerate(authors) if author.get("corresponding_author", False)]
+    if len(corresponding_indices) > 1:
+        # Unmark all but the last corresponding author
+        for idx in corresponding_indices[:-1]:
+            authors[idx]["corresponding_author"] = False
+        logger.warning(
+            f"Multiple corresponding authors found. Only keeping the last one: "
+            f"{authors[corresponding_indices[-1]].get('name', 'Unknown')}"
+        )
+
+    # Validate author data
+    validate_author_data(authors)
+
+    # Build affiliation map (shortname -> full data)
+    affiliation_map = {}
+    for affiliation in affiliations:
+        shortname = affiliation.get("shortname", "")
+        if shortname:
+            affiliation_map[shortname] = affiliation
+
+    # Process authors: decode emails
+    processed_authors = []
+    for author in authors:
+        author_copy = author.copy()
+
+        # Decode email64 if present
+        if "email64" in author_copy:
+            try:
+                author_copy["email"] = decode_email(author_copy["email64"])
+            except ValueError as e:
+                logger.warning(f"Failed to decode email64 for {author_copy.get('name', 'Unknown')}: {e}")
+                author_copy["email"] = ""
+        elif "email" not in author_copy:
+            author_copy["email"] = ""
+
+        processed_authors.append(author_copy)
+
+    # Generate TSV file
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, delimiter="\t", quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
+
+        # Write header row
+        header = [
+            "Email",
+            "Institution",
+            "First Name",
+            "Middle Name(s)/Initial(s)",
+            "Last Name",
+            "Suffix",
+            "Corresponding Author",
+            "Home Page URL",
+            "Collaborative Group/Consortium",
+            "ORCiD",
+        ]
+        writer.writerow(header)
+
+        # Write author rows
+        for author in processed_authors:
+            row = format_author_row(author, affiliation_map)
+            writer.writerow(row)
+
+    logger.info(f"Generated bioRxiv author template: {output_path}")
+    return output_path
+
+
+def prepare_biorxiv_package(
+    manuscript_path: Path,
+    output_dir: Path,
+    biorxiv_dir: Path | None = None,
+) -> Path:
+    """Prepare bioRxiv submission package.
+
+    Creates a directory containing:
+    - biorxiv_authors.tsv (author template)
+    - manuscript PDF
+    - source files (TeX, figures, bibliography)
+
+    Args:
+        manuscript_path: Path to the manuscript directory
+        output_dir: Path to the rxiv-maker output directory
+        biorxiv_dir: Path where bioRxiv submission files will be created.
+                     If None, defaults to {output_dir}/biorxiv_submission
+
+    Returns:
+        Path to the bioRxiv submission directory
+
+    Raises:
+        FileNotFoundError: If required files are missing
+    """
+    output_path = Path(output_dir)
+
+    # Default bioRxiv directory to be inside the output directory
+    if biorxiv_dir is None:
+        biorxiv_dir = output_path / "biorxiv_submission"
+
+    biorxiv_path = Path(biorxiv_dir)
+
+    # Create clean bioRxiv directory
+    if biorxiv_path.exists():
+        shutil.rmtree(biorxiv_path)
+    biorxiv_path.mkdir(parents=True)
+
+    manuscript_name = manuscript_path.name if manuscript_path else "manuscript"
+    logger.info(f"Preparing bioRxiv submission package for '{manuscript_name}' in {biorxiv_path}")
+
+    # 1. Copy the bioRxiv authors TSV file (already generated)
+    tsv_source = output_path / "biorxiv_authors.tsv"
+    if not tsv_source.exists():
+        raise FileNotFoundError(
+            f"bioRxiv author template not found: {tsv_source}\n"
+            "Please run TSV generation first or ensure output directory is correct."
+        )
+    shutil.copy2(tsv_source, biorxiv_path / "biorxiv_authors.tsv")
+    logger.info("✓ Copied author template: biorxiv_authors.tsv")
+
+    # 2. Find and copy the manuscript PDF
+    pdf_files = list(output_path.glob("*.pdf"))
+    main_pdf = None
+    for pdf in pdf_files:
+        # Skip supplementary PDFs
+        if "supplementary" not in pdf.name.lower():
+            main_pdf = pdf
+            break
+
+    if not main_pdf:
+        logger.warning("⚠ No manuscript PDF found in output directory")
+    else:
+        shutil.copy2(main_pdf, biorxiv_path / main_pdf.name)
+        logger.info(f"✓ Copied manuscript PDF: {main_pdf.name}")
+
+    # 3. Copy source files for submission
+    # Copy TeX files
+    tex_files = list(output_path.glob("*.tex"))
+    for tex_file in tex_files:
+        shutil.copy2(tex_file, biorxiv_path / tex_file.name)
+        logger.info(f"✓ Copied TeX file: {tex_file.name}")
+
+    # Copy style file
+    style_file = output_path / "rxiv_maker_style.cls"
+    if style_file.exists():
+        shutil.copy2(style_file, biorxiv_path / "rxiv_maker_style.cls")
+        logger.info("✓ Copied style file: rxiv_maker_style.cls")
+
+    # Copy bibliography
+    bib_file = output_path / "03_REFERENCES.bib"
+    if bib_file.exists():
+        shutil.copy2(bib_file, biorxiv_path / "03_REFERENCES.bib")
+        logger.info("✓ Copied bibliography: 03_REFERENCES.bib")
+
+    # Copy FIGURES directory
+    figures_source = output_path / "FIGURES"
+    if figures_source.exists() and figures_source.is_dir():
+        figures_dest = biorxiv_path / "FIGURES"
+        shutil.copytree(figures_source, figures_dest)
+        figure_count = len(list(figures_dest.rglob("*")))
+        logger.info(f"✓ Copied FIGURES directory ({figure_count} files)")
+
+    logger.info(f"\n📦 bioRxiv package prepared in {biorxiv_path}")
+    return biorxiv_path
+
+
+def create_biorxiv_zip(
+    biorxiv_path: Path,
+    zip_filename: str = "biorxiv_submission.zip",
+    manuscript_path: Path | None = None,
+) -> Path:
+    """Create a ZIP file for bioRxiv submission.
+
+    Args:
+        biorxiv_path: Path to the bioRxiv submission directory
+        zip_filename: Name of the ZIP file to create
+        manuscript_path: Optional manuscript path for naming
+
+    Returns:
+        Path to the created ZIP file
+    """
+    # Use manuscript-aware naming if manuscript path is provided
+    if manuscript_path and zip_filename == "biorxiv_submission.zip":
+        manuscript_name = manuscript_path.name
+        zip_filename = f"{manuscript_name}_biorxiv.zip"
+
+    zip_path = Path(zip_filename).resolve()
+
+    # Define auxiliary files that should be excluded
+    auxiliary_extensions = {".aux", ".blg", ".log", ".out", ".fls", ".fdb_latexmk", ".synctex.gz"}
+
+    logger.info(f"\n📁 Creating ZIP package: {zip_path}")
+
+    excluded_files = []
+    included_files = []
+
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file_path in biorxiv_path.rglob("*"):
+            if file_path.is_file():
+                # Check if file should be excluded (auxiliary files)
+                should_exclude = file_path.suffix.lower() in auxiliary_extensions
+
+                if should_exclude:
+                    excluded_files.append(file_path.name)
+                    continue
+
+                # Store files with relative paths
+                arcname = file_path.relative_to(biorxiv_path)
+                zipf.write(file_path, arcname)
+                included_files.append(str(arcname))
+
+    logger.info(f"✅ ZIP created: {zip_path}")
+    logger.info(f"   Files included: {len(included_files)}")
+    if excluded_files:
+        logger.info(f"   Files excluded: {len(excluded_files)} (auxiliary files)")
+
+    return zip_path

{rxiv_maker-1.18.5.dist-info → rxiv_maker-1.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxiv-maker
-Version: 1.18.5
+Version: 1.19.0
 Summary: Write scientific preprints in Markdown. Generate publication-ready PDFs efficiently.
 Project-URL: Homepage, https://github.com/HenriquesLab/rxiv-maker
 Project-URL: Documentation, https://github.com/HenriquesLab/rxiv-maker#readme

{rxiv_maker-1.18.5.dist-info → rxiv_maker-1.19.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 rxiv_maker/__init__.py,sha256=p04JYC5ZhP6dLXkoWVlKNyiRvsDE1a4C88f9q4xO3tA,3268
-rxiv_maker/__version__.py,sha256=i8ukZW5rVDoXBNiuInaBgxVXM535F7b6jCi26fK-JBw,51
+rxiv_maker/__version__.py,sha256=s7-5Jsk7L8O8kxknnMqV6RyUG2rsUkOD8DjGMhagzNo,51
 rxiv_maker/rxiv_maker_cli.py,sha256=9Lu_mhFPXwx5jzAR6StCNxwCm_fkmP5qiOYdNuh_AwI,120
 rxiv_maker/validate.py,sha256=AIzgP59KbCQJqC9WIGfUdVv0xI6ud9g1fFznQkaGz5Q,9373
 rxiv_maker/cli/__init__.py,sha256=Jw0DTFUSofN-02xpVrt1UUzRcgH5NNd-GPNidhmNwpU,77
@@ -7,10 +7,11 @@ rxiv_maker/cli/__main__.py,sha256=OEaQSb9q7MK3MMkEJfOdzzJuDvr5LAeILtHQesdYxWU,13
 rxiv_maker/cli/framework.py,sha256=enBb4d48ZsgB-4H6zjzSGnMFEgPd1T7cnUjNcOOPKKY,3895
 rxiv_maker/cli/interactive.py,sha256=lgfZVFf1rdJKZtHPogNiEPSwhMlnU2_dSFU9CJjM-7E,18907
 rxiv_maker/cli/interactive_prompts.py,sha256=jhyCdP54TIYHzgAD84lwcyat3tCGVeK9vmyfLHuwL6I,11830
-rxiv_maker/cli/main.py,sha256=AwqEcq46MPu8T72iqO39RWemtiD7WiAeUkfxACMUdgs,8697
-rxiv_maker/cli/commands/__init__.py,sha256=jp_dRdPBJNhgZxA7ccAplbtESUBtb81k-boLA5yi3Fg,1396
+rxiv_maker/cli/main.py,sha256=ieSKR954s2ppE5SiwDYa5Xwr3vh_xzQxwI1tf2tMcYE,8743
+rxiv_maker/cli/commands/__init__.py,sha256=Kcof7u2l2XE1M4g3AAuio5cTX6WSt4ly1ROujHH54xw,1440
 rxiv_maker/cli/commands/arxiv.py,sha256=nlAS36lgTNjd6Hn1cdporXFZskf7-Jl-fZLvjxc6gjo,1245
 rxiv_maker/cli/commands/bibliography.py,sha256=3a4gNtY7Lvd5-mwIj-vCD5WwRDgMqPT37tJETthKYKA,2956
+rxiv_maker/cli/commands/biorxiv.py,sha256=nKu7nAeTVeWH_3Q-gQnY5Y_Q9YnXZEC50MqQzEwqua4,1670
 rxiv_maker/cli/commands/build.py,sha256=v513o3duOD9YvKUoOTggqshqQzwD4THBVIAClJTnx60,3525
 rxiv_maker/cli/commands/cache_management.py,sha256=y58QsuSjzCz_IhY6iXnir8OoblHW5ZBMqItfnfjTP-Y,4577
 rxiv_maker/cli/commands/changelog.py,sha256=OzEay8E8sWfXagjXyWiKwfE-OC9UKokWB7mbINp36t4,8461
@@ -33,13 +34,13 @@ rxiv_maker/cli/commands/upgrade.py,sha256=UpdqEQwbNYmDMbSrYGv_pVd-7u8PPT3US5RVEN
 rxiv_maker/cli/commands/validate.py,sha256=3JghFQevJvQDQII4p_QWbQXMEUyDpM-t9-WxtaT4edo,1629
 rxiv_maker/cli/commands/version.py,sha256=VMlfSxxsrZH02d24MXLUDZfHBW39yZRpWxUpMhQ-X0Y,2737
 rxiv_maker/cli/framework/__init__.py,sha256=4FPXdP8J6v4eeEn46mwY0VtnwxjR1jnW_kTrXykQlQs,2704
-rxiv_maker/cli/framework/base.py,sha256=GcDFFOGVrLSlRgwDPmMkEAL60TbgT-maTyiCp1g-BrA,7886
+rxiv_maker/cli/framework/base.py,sha256=HqjVHVJzBKLk9-lH6PQrVxYedvs1efcLZ94IxVq7rmE,11242
 rxiv_maker/cli/framework/cache_commands.py,sha256=J91UYLTsLTRoNdzuhAbNL2bJJovYYfX3T9jI8cNUBWU,9897
 rxiv_maker/cli/framework/config_commands.py,sha256=a1uOQkCCw3d4qlro3OwHIorcoNg03T_R4-HbfVb-hmQ,19336
 rxiv_maker/cli/framework/content_commands.py,sha256=RilxKeG2c1m2fu0CtWAvP3cGh11DGx9P-nh2kIewAg4,22596
 rxiv_maker/cli/framework/decorators.py,sha256=fh085e3k1CaLSMoZevt8hvgnEuejrf-mcNS-dwXoY_A,10365
 rxiv_maker/cli/framework/utility_commands.py,sha256=drIAc1TAYpne76gj7SZeZhPozVAY5uL9GFPVT_Ez0-E,26437
-rxiv_maker/cli/framework/workflow_commands.py,sha256=Csls8VGmNCWPjpY9PMfdIAdzDhD_ZmSfRkhdcUihzpk,32699
+rxiv_maker/cli/framework/workflow_commands.py,sha256=CguePd76EjdT53ab9a9clv3S-FSpBAXioQKmto1VS3w,35422
 rxiv_maker/config/defaults.py,sha256=vHyLGVxe5-z9TLxu5f6NhquPvqQkER_KZv_j1I4_dHQ,3055
 rxiv_maker/config/validator.py,sha256=9XDPfo_YgasGt6NLkl6HIhaGh1fr6XsFNiXU2DSsivw,38299
 rxiv_maker/converters/__init__.py,sha256=d7WGsRwWqRQWO117IkKDP0Ap0ERiK0N2-dXHInye3_A,685
@@ -99,6 +100,7 @@ rxiv_maker/engines/operations/generate_docs.py,sha256=8d_oVYUuRRqTuYN1KnJKqM5Ydp
 rxiv_maker/engines/operations/generate_figures.py,sha256=YeKzH6qVsuPGjtCsvWugLJoys6y73xTyO7Y5g30KM20,38730
 rxiv_maker/engines/operations/generate_preprint.py,sha256=wpKDAu2RLJ4amSdhX5GZ7hU-iTsTRt4etcEA7AZYp04,2662
 rxiv_maker/engines/operations/prepare_arxiv.py,sha256=cd0JN5IO-Wy9T8ab75eibyaA8_K8Gpwrz2F-95OMnx4,21551
+rxiv_maker/engines/operations/prepare_biorxiv.py,sha256=-Ok4iwnLsgNk6xJ9HSk74_7UBammJRTF3r8ISy_qDjc,13858
 rxiv_maker/engines/operations/setup_environment.py,sha256=gERuThHTldH0YqgXn85995deHBP6csY1ZhCNgU6-vFg,12691
 rxiv_maker/engines/operations/track_changes.py,sha256=jJZ-XnTFx8TMvcnX8_9D7ydc0G01S1PnckLkxHRTX1g,24722
 rxiv_maker/engines/operations/validate.py,sha256=OVmtRVtG-r1hoA8IqYaNC-ijN1a5ixM3X5Z8Gda-O2M,17142
@@ -194,8 +196,8 @@ rxiv_maker/validators/doi/metadata_comparator.py,sha256=euqHhKP5sHQAdZbdoAahUn6Y
 rxiv_maker/tex/template.tex,sha256=_tPtxrurn3sKTt9Kfa44lPdPyT44vHbDUOGqldU9r2s,1378
 rxiv_maker/tex/style/rxiv_maker_style.bst,sha256=jbVqrJgAm6F88cow5vtZuPBwwmlcYykclTm8RvZIo6Y,24281
 rxiv_maker/tex/style/rxiv_maker_style.cls,sha256=6VDmZE0uvYWog6rcYi2K_NIM9-Pgjx9AFdRg_sTheK0,24374
-rxiv_maker-1.18.5.dist-info/METADATA,sha256=3MGWQNaVnAJM_7nypR3gtVuh5BTgnCwJ5eZ8S_MTrf8,18432
-rxiv_maker-1.18.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-rxiv_maker-1.18.5.dist-info/entry_points.txt,sha256=ghCN0hI9A1GlG7QY5F6E-xYPflA8CyS4B6bTQ1YLop0,97
-rxiv_maker-1.18.5.dist-info/licenses/LICENSE,sha256=GSZFoPIhWDNJEtSHTQ5dnELN38zFwRiQO2antBezGQk,1093
-rxiv_maker-1.18.5.dist-info/RECORD,,
+rxiv_maker-1.19.0.dist-info/METADATA,sha256=cM3QcAip52NGWPYbS5RqFTaP1Q3L6nsN6z0UmBt6YT4,18432
+rxiv_maker-1.19.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rxiv_maker-1.19.0.dist-info/entry_points.txt,sha256=ghCN0hI9A1GlG7QY5F6E-xYPflA8CyS4B6bTQ1YLop0,97
+rxiv_maker-1.19.0.dist-info/licenses/LICENSE,sha256=GSZFoPIhWDNJEtSHTQ5dnELN38zFwRiQO2antBezGQk,1093
+rxiv_maker-1.19.0.dist-info/RECORD,,