scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/scholar/pipelines/ScholarPipelineSingle.py

@@ -1,57 +1,40 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-13 09:05:52 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/scholar/pipelines/ScholarPipelineSingle.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/scholar/pipelines/ScholarPipelineSingle.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
+# Timestamp: "2026-01-22 (ywatanabe)"
+# File: src/scitex/scholar/pipelines/ScholarPipelineSingle.py
 """
+Single paper acquisition pipeline orchestrator.
+
 Functionalities:
   - Orchestrates full paper acquisition pipeline from query to storage
-  - Single command: query (DOI/title) + project → complete paper in library
+  - Single command: query (DOI/title) + project -> complete paper in library
   - Coordinates all workers: metadata, URLs, download, extraction, storage
-  - Supports resumable processing (checks existing data at each step)
-  - Creates MASTER/{8-digit-ID}/ and project symlinks
-
-Dependencies:
-  - packages:
-    - playwright
-    - pydantic
 
 IO:
-  - input-files:
-    - None (starts from query string)
-
   - output-files:
     - library/MASTER/{paper_id}/metadata.json
     - library/MASTER/{paper_id}/main.pdf
     - library/MASTER/{paper_id}/content.txt
+    - library/MASTER/{paper_id}/tables.json
+    - library/MASTER/{paper_id}/images/
     - library/{project}/{paper_id} -> ../MASTER/{paper_id}
 """
 
-"""Imports"""
-import argparse
+from __future__ import annotations
+
 import asyncio
-import hashlib
-from pathlib import Path
 from typing import Optional
 
+import scitex as stx
 from scitex import logging
-from scitex.scholar.core import Paper
 from scitex.scholar.storage import PaperIO
 
-logger = logging.getLogger(__name__)
+from ._single_steps import PipelineHelpersMixin, PipelineStepsMixin
 
-"""Functions & Classes"""
+logger = logging.getLogger(__name__)
 
 
-class ScholarPipelineSingle:
-    """Orchestrates full paper acquisition pipeline"""
+class ScholarPipelineSingle(PipelineStepsMixin, PipelineHelpersMixin):
+    """Orchestrates full paper acquisition pipeline."""
 
     def __init__(
         self, browser_mode: str = "interactive", chrome_profile: str = "system"
@@ -65,677 +48,121 @@ class ScholarPipelineSingle:
         doi_or_title: str,
         project: Optional[str] = None,
         force: bool = False,
-    ) -> Paper:
+    ):
         """Process single paper from query (DOI or Title) to complete storage.
 
         Pipeline:
-        1. Resolve DOI (if doi_or_title is title)
-        2. Create Paper object with 8-digit ID
-        3. Resolve metadata (ScholarEngine.search_async)
-        4. Enrich impact factor (ImpactFactorEngine)
-        5. Find PDF URLs
-        6. Download PDF (with manual mode support)
-        7. Extract content
-        8. Save to MASTER/{8-digit-ID}/
+        1. Normalize as DOI
+        2. Create Paper object (resolve DOI from title if needed)
+        3. Add paper ID (8-digit hash)
+        4. Resolve metadata (ScholarEngine)
+        5. Setup browser
+        6. Find PDF URLs
+        7. Download PDF
+        8. Extract content (text, tables, images)
         9. Link to project (if specified)
+        10. Log final status
 
         Args:
             doi_or_title: DOI or title string
             project: Optional project name for symlinking
             force: If True, ignore existing files and force fresh processing
 
-        Returns:
+        Returns
+        -------
             Tuple of (Complete Paper object, symlink_path)
         """
-
-        # Step 1. Resolve DOI (if doi_or_title is title)
+        # Step 1-3: Initialize
         doi = self._step_01_normalize_as_doi(doi_or_title)
-
-        # Step 2. Create Paper object with 8-digit ID
         paper = await self._step_02_create_paper(doi, doi_or_title)
-
-        # Step 3. Resolve metadata (ScholarEngine.search_async)
         paper = self._step_03_add_paper_id(paper)
 
         io = PaperIO(paper)
         logger.info(f"{self.name}: Paper directory: {io.paper_dir}")
+
         with logger.to(io.paper_dir / "logs" / "pipeline.log"):
-            # Step 4. Enrich impact factor (ImpactFactorEngine)
+            # Step 4: Metadata
             paper = await self._step_04_resolve_metadata(paper, io, force)
 
-            # Step 5. Find PDF URLs
+            # Steps 5-7: Browser and PDF
             browser_manager, context, auth_gateway = await self._step_05_setup_browser(
                 paper, io
             )
             if context:
-                # Step 6. Download PDF (with manual mode support)
                 await self._step_06_find_pdf_urls(
-                    paper, io, context, auth_gateway, force
+                    paper, io, context, auth_gateway, force, browser_manager
                 )
-
-                # Step 7. Extract content
                 await self._step_07_download_pdf(
-                    paper, io, context, auth_gateway, force
+                    paper, io, context, auth_gateway, force, browser_manager
                 )
             if browser_manager:
                 await browser_manager.close()
-            # Step 8. Save to MASTER/{8-digit-ID}/
+
+            # Step 8: Content extraction
             self._step_08_extract_content(io, force)
 
-            # Step 9. Link to project (if specified)
+            # Step 9-10: Finalize
             symlink_path = self._step_09_link_to_project(paper, io, project)
-
-            # Step 10. Print final status
             self._step_10_log_final_status(io)
 
             return paper, symlink_path
 
-    # ----------------------------------------
-    # Steps
-    # ----------------------------------------
-    def _step_01_normalize_as_doi(self, doi_or_title):
-        logger.info(f"{self.name}: Processing Query: {doi_or_title}")
-        is_doi = doi_or_title.strip().startswith("10.")
-        doi = doi_or_title.strip() if is_doi else None
-        return doi
-
-    async def _step_02_create_paper(self, doi, doi_or_title):
-        """Step 2: Create Paper object and resolve DOI from title if needed."""
-        paper = Paper()
-
-        if doi:
-            paper.metadata.id.doi = doi
-            paper.metadata.id.doi_engines = ["user_input"]
-        else:
-            # Use ScholarEngine to resolve DOI from title
-            from scitex.scholar.metadata_engines import ScholarEngine
-
-            engine = ScholarEngine()
-            metadata_dict = await engine.search_async(title=doi_or_title)
-
-            if metadata_dict and metadata_dict.get("id", {}).get("doi"):
-                doi = metadata_dict["id"]["doi"]
-                paper.metadata.id.doi = doi
-                paper.metadata.id.doi_engines = metadata_dict["id"].get(
-                    "doi_engines", ["ScholarEngine"]
-                )
-                logger.success(f"{self.name}: DOI resolved from title: {doi}")
-
-                # Merge other metadata while we have it
-                self._merge_metadata_into_paper(paper, metadata_dict)
-            else:
-                logger.error(
-                    f"{self.name}: Could not resolve DOI from title: {doi_or_title}"
-                )
-                raise ValueError(f"No DOI found for title: {doi_or_title}")
-
-        return paper
-
-    def _step_03_add_paper_id(self, paper):
-        paper_id = self._generate_paper_id(paper.metadata.id.doi)
-        paper.container.library_id = paper_id
-        logger.info(f"{self.name}: Library ID: {paper_id}")
-        return paper
-
-    async def _step_04_resolve_metadata(self, paper, io, force):
-        if not io.has_metadata() or force:
-            logger.info(f"{self.name}: Resolving metadata...")
-            from scitex.scholar.metadata_engines import ScholarEngine
-
-            engine = ScholarEngine()
-            metadata_dict = await engine.search_async(doi=paper.metadata.id.doi)
-            if metadata_dict:
-                self._merge_metadata_into_paper(paper, metadata_dict)
-                self._enrich_impact_factor(paper)
-                io.save_metadata()
-                logger.success(f"{self.name}: Metadata enriched from search engines")
-            else:
-                paper.metadata.basic.title = "Pending metadata resolution"
-                paper.metadata.basic.title_engines = ["pending"]
-                io.save_metadata()
-                logger.warning(
-                    f"{self.name}: No metadata found from engines, saved basic metadata"
-                )
-        else:
-            logger.info(f"{self.name}: Metadata exists, loading...")
-            paper = io.load_metadata()
-            if paper.metadata.basic.title == "Pending metadata resolution":
-                logger.info(f"{self.name}: Enriching existing metadata...")
-                from scitex.scholar.metadata_engines import ScholarEngine
-
-                engine = ScholarEngine()
-                metadata_dict = await engine.search_async(doi=paper.metadata.id.doi)
-                if metadata_dict:
-                    self._merge_metadata_into_paper(paper, metadata_dict)
-                    self._enrich_impact_factor(paper)
-                    io.save_metadata()
-                    logger.success(
-                        f"{self.name}: Metadata enriched from search engines"
-                    )
-        return paper
-
-    async def _step_05_setup_browser(self, paper, io):
-        needs_browser = not paper.metadata.url.pdfs or not io.has_pdf()
-        if not needs_browser:
-            return None, None, None
-        from scitex.scholar import ScholarAuthManager, ScholarBrowserManager
-        from scitex.scholar.auth import AuthenticationGateway
-
-        logger.info(
-            f"{self.name}: Setting up browser (profile: {self.chrome_profile})..."
-        )
-        auth_manager = ScholarAuthManager()
-        browser_manager = ScholarBrowserManager(
-            chrome_profile_name=self.chrome_profile,
-            browser_mode=self.browser_mode,
-            auth_manager=auth_manager,
-        )
-        (
-            browser,
-            context,
-        ) = await browser_manager.get_authenticated_browser_and_context_async()
-        auth_gateway = AuthenticationGateway(
-            auth_manager=auth_manager,
-            browser_manager=browser_manager,
-        )
-        return browser_manager, context, auth_gateway
-
-    async def _step_06_find_pdf_urls(self, paper, io, context, auth_gateway, force):
-        if not paper.metadata.url.pdfs or force:
-            logger.info(f"{self.name}: Finding PDF URLs...")
-            try:
-                url_context = await auth_gateway.prepare_context_async(
-                    doi=paper.metadata.id.doi,
-                    context=context,
-                )
-                publisher_url = (
-                    url_context.url if url_context else paper.metadata.id.doi
-                )
-            except Exception as e:
-                logger.warning(f"{self.name}: Auth gateway failed: {e}")
-                publisher_url = paper.metadata.id.doi
-            from scitex.scholar import ScholarURLFinder
-
-            url_finder = ScholarURLFinder(context)
-            urls = await url_finder.find_pdf_urls(publisher_url)
-            paper.metadata.url.pdfs = urls
-            paper.metadata.url.pdfs_engines = ["ScholarURLFinder"]
-            io.save_metadata()
-            logger.info(f"{self.name}: Found {len(urls)} PDF URL(s)")
-        else:
-            logger.info(
-                f"{self.name}: PDF URLs exist in metadata ({len(paper.metadata.url.pdfs)} URLs)"
-            )
-
-    async def _step_07_download_pdf_from_url(
-        self, paper, io, context, auth_gateway, downloader
-    ):
-        pdf_url = paper.metadata.url.pdfs[0]
-        if isinstance(pdf_url, dict):
-            pdf_url = pdf_url["url"]
-        logger.info(f"{self.name}: PDF URL: {pdf_url}")
-        try:
-            url_context = await auth_gateway.prepare_context_async(
-                doi=paper.metadata.id.doi,
-                context=context,
-            )
-        except Exception as e:
-            logger.warn(str(e))
-        temp_pdf_path = io.paper_dir / "temp.pdf"
-        downloaded_file = await downloader.download_from_url(
-            pdf_url,
-            output_path=temp_pdf_path,
-            doi=paper.metadata.id.doi,
-        )
-        return downloaded_file, temp_pdf_path
-
-    def _step_07_handle_downloaded_pdf(self, paper, io, downloaded_file, temp_pdf_path):
-        if downloaded_file == temp_pdf_path and temp_pdf_path.exists():
-            import shutil
-
-            main_pdf = io.get_pdf_path()
-            shutil.move(str(temp_pdf_path), str(main_pdf))
-            paper.metadata.path.pdfs = [str(main_pdf)]
-            paper.container.pdf_size_bytes = main_pdf.stat().st_size
-            io.save_metadata()
-            logger.success(
-                f"{self.name}: PDF downloaded directly to MASTER ({str(main_pdf)})"
-            )
-        else:
-            io.save_pdf(downloaded_file)
-            io.save_metadata()
-        logger.info(f"{self.name}: PDF downloaded and saved ({str(downloaded_file)})")
-        logger.info(f"{self.name}: Updated metadata.path.pdfs")
-
-    def _step_07_check_manual_download(self, io):
-        logger.warning(f"{self.name}: Automated download returned None")
-        logger.info(
-            f"{self.name}: Checking downloads directory for manual downloads..."
-        )
-        import time
-
-        from scitex.scholar import ScholarConfig
-
-        config = ScholarConfig()
-        downloads_dir = config.get_library_downloads_dir()
-        current_time = time.time()
-        recent_pdfs = []
-        for pdf_path in downloads_dir.glob("*"):
-            if pdf_path.is_file() and pdf_path.stat().st_size > 100_000:
-                age_seconds = current_time - pdf_path.stat().st_mtime
-                if age_seconds < 600:
-                    recent_pdfs.append((pdf_path, age_seconds))
-        if recent_pdfs:
-            recent_pdfs.sort(key=lambda x: x[1])
-            latest_pdf = recent_pdfs[0][0]
-            logger.info(
-                f"{self.name}: Found recent PDF: {latest_pdf.name} ({latest_pdf.stat().st_size / 1e6:.2f} MB)"
-            )
-            logger.info(f"{self.name}: Assuming this is the manually downloaded PDF")
-            io.save_pdf(latest_pdf)
-            io.save_metadata()
-            logger.success(f"{self.name}: Manually downloaded PDF saved to MASTER")
-            logger.info(f"{self.name}: Updated metadata.path.pdfs")
-        else:
-            logger.warning(f"{self.name}: No recent PDFs found in downloads directory")
-            logger.warning(
-                f"{self.name}: PDF download incomplete - manual intervention required"
-            )
-
-    async def _step_07_download_pdf(self, paper, io, context, auth_gateway, force):
-        if (not io.has_pdf() or force) and paper.metadata.url.pdfs:
-            logger.info(f"{self.name}: Downloading PDF...")
-            from scitex.scholar.pdf_download import ScholarPDFDownloader
-
-            downloader = ScholarPDFDownloader(context)
-            downloaded_file, temp_pdf_path = await self._step_07_download_pdf_from_url(
-                paper, io, context, auth_gateway, downloader
-            )
-            if downloaded_file:
-                self._step_07_handle_downloaded_pdf(
-                    paper, io, downloaded_file, temp_pdf_path
-                )
-            else:
-                self._step_07_check_manual_download(io)
-        elif io.has_pdf():
-            logger.info(f"{self.name}: PDF already exists, skipping download")
-
-    def _step_08_extract_content(self, io, force):
-        if io.has_pdf() and (not io.has_content() or force):
-            logger.info(f"{self.name}: Extracting content...")
-            import scitex
-
-            try:
-                pdf_path = io.get_pdf_path()
-                content = scitex.io.load(str(pdf_path), ext="pdf")
-                if hasattr(content, "full_text"):
-                    io.save_text(content.full_text)
-                    logger.info(f"{self.name}: Content extracted")
-            except Exception as e:
-                logger.warning(f"{self.name}: Content extraction failed: {e}")
-
-    def _step_09_link_to_project(self, paper, io, project):
-        if project:
-            logger.info(f"{self.name}: Linking to project: {project}")
-            return self._link_to_project(paper, project, io)
-        return None
-
-    def _step_10_log_final_status(self, io):
-        logger.info(f"{self.name}: Complete")
-        status = io.get_all_files()
-        for filename, exists in status.items():
-            logger.info(f"  {'✓' if exists else '✗'} {filename}")
-
-    # ----------------------------------------
-    # Helper functions
-    # ----------------------------------------
-    def _link_to_project(self, paper: Paper, project: str, io: PaperIO) -> Path:
-        """Create human-readable symlink in project directory."""
-        from scitex.scholar import ScholarConfig
 
-        config = ScholarConfig()
-        project_dir = config.path_manager.get_library_project_dir(project)
-
-        # Gather data for entry name
-        pdf_files = list(io.paper_dir.glob("*.pdf"))
-        n_pdfs = len(pdf_files)
-        citation_count = paper.metadata.citation_count.total or 0
-        impact_factor = int(paper.metadata.publication.impact_factor or 0)
-        year = paper.metadata.basic.year or 0
-        first_author = (
-            paper.metadata.basic.authors[0].split()[-1]
-            if paper.metadata.basic.authors
-            else "Unknown"
-        )
-        journal_name = (
-            paper.metadata.publication.short_journal
-            or paper.metadata.publication.journal
-            or "Unknown"
-        )
-
-        # Use PathManager to generate entry name (single source of truth)
-        entry_name = config.path_manager.get_library_project_entry_dirname(
-            n_pdfs=n_pdfs,
-            citation_count=citation_count,
-            impact_factor=impact_factor,
-            year=year,
-            first_author=first_author,
-            journal_name=journal_name,
-        )
-
-        # Create relative symlink directly
-        symlink_path = project_dir / entry_name
-        target_path = Path("../MASTER") / paper.container.library_id
-
-        # Remove existing symlink if present
-        if symlink_path.exists() or symlink_path.is_symlink():
-            symlink_path.unlink()
-
-        # Create symlink with relative path (don't resolve to absolute)
-        symlink_path.symlink_to(target_path)
-        logger.success(f"{self.name}: Created symlink: {project}/{entry_name}")
-
-        return symlink_path
-
-    def _generate_paper_id(self, doi: str) -> str:
-        """Generate 8-digit library ID from DOI"""
-        content = f"DOI:{doi}"
-        return hashlib.md5(content.encode()).hexdigest()[:8].upper()
-
-    def _merge_metadata_into_paper(self, paper: Paper, metadata_dict: dict) -> None:
-        """Merge metadata dictionary from ScholarEngine into Paper object."""
-
-        # Helper to safely update field with engine tracking and type conversion
-        def update_field(section, field_name, value, engines):
-            if value is not None:
-                # Convert types to match Paper model expectations
-                # IDs should be strings
-                if section == "id" and not isinstance(value, str):
-                    value = str(value)
-
-                # Year should be integer
-                if field_name == "year" and not isinstance(value, int):
-                    try:
-                        value = int(value)
-                    except (ValueError, TypeError):
-                        logger.warning(
-                            f"{self.name}: Could not convert year '{value}' to int"
-                        )
-                        return
-
-                # Citation counts should be integers
-                if section == "citation_count" and not isinstance(value, int):
-                    try:
-                        value = int(value)
-                    except (ValueError, TypeError):
-                        logger.warning(
-                            f"{self.name}: Could not convert citation count '{value}' to int"
-                        )
-                        return
-
-                try:
-                    section_obj = getattr(paper.metadata, section)
-                    setattr(section_obj, field_name, value)
-                    setattr(section_obj, f"{field_name}_engines", engines)
-                except Exception as e:
-                    logger.warning(
-                        f"{self.name}: Could not set {section}.{field_name}: {e}"
-                    )
-
-        # ID section
-        if "id" in metadata_dict:
-            id_data = metadata_dict["id"]
-            for field in [
-                "doi",
-                "arxiv_id",
-                "pmid",
-                "corpus_id",
-                "semantic_id",
-                "ieee_id",
-                "scholar_id",
-            ]:
-                if field in id_data:
-                    update_field(
-                        "id",
-                        field,
-                        id_data[field],
-                        id_data.get(f"{field}_engines", []),
-                    )
-
-        # Basic section
-        if "basic" in metadata_dict:
-            basic_data = metadata_dict["basic"]
-            for field in [
-                "title",
-                "authors",
-                "year",
-                "abstract",
-                "keywords",
-                "type",
-            ]:
-                if field in basic_data:
-                    update_field(
-                        "basic",
-                        field,
-                        basic_data[field],
-                        basic_data.get(f"{field}_engines", []),
-                    )
-
-        # Citation count section
-        if "citation_count" in metadata_dict:
-            cc_data = metadata_dict["citation_count"]
-            # Handle total
-            if "total" in cc_data:
-                update_field(
-                    "citation_count",
-                    "total",
-                    cc_data["total"],
-                    cc_data.get("total_engines", []),
-                )
-            # Handle year-specific counts (convert "2015" → "y2015" for Pydantic model)
-            for year in range(2015, 2026):
-                year_str = str(year)
-                year_field = f"y{year}"
-                if year_str in cc_data:
-                    update_field(
-                        "citation_count",
-                        year_field,
-                        cc_data[year_str],
-                        cc_data.get(f"{year_str}_engines", []),
-                    )
-
-        # Publication section
-        if "publication" in metadata_dict:
-            pub_data = metadata_dict["publication"]
-            for field in [
-                "journal",
-                "short_journal",
-                "impact_factor",
-                "issn",
-                "volume",
-                "issue",
-                "first_page",
-                "last_page",
-                "pages",
-                "publisher",
-            ]:
-                if field in pub_data:
-                    update_field(
-                        "publication",
-                        field,
-                        pub_data[field],
-                        pub_data.get(f"{field}_engines", []),
-                    )
-
-        # URL section
-        if "url" in metadata_dict:
-            url_data = metadata_dict["url"]
-            for field in ["doi", "publisher", "arxiv", "corpus_id"]:
-                if field in url_data:
-                    update_field(
-                        "url",
-                        field,
-                        url_data[field],
-                        url_data.get(f"{field}_engines", []),
-                    )
-
-        logger.info(f"{self.name}: Merged metadata into Paper object")
-
-    def _enrich_impact_factor(self, paper: Paper) -> None:
-        """Add journal impact factor to paper metadata if not present."""
-        # Skip if already has impact factor
-        if paper.metadata.publication.impact_factor:
-            logger.success(f"{self.name}: Impact factor already present")
-            return
-
-        # Need journal name to lookup impact factor
-        journal = (
-            paper.metadata.publication.short_journal
-            or paper.metadata.publication.journal
-        )
-
-        if not journal:
-            logger.debug(f"{self.name}: No journal name, skipping IF lookup")
-            return
-
-        try:
-            from scitex.scholar.impact_factor import ImpactFactorEngine
-
-            if_engine = ImpactFactorEngine()
-            metrics = if_engine.get_metrics(journal)
-
-            if metrics and metrics.get("impact_factor"):
-                paper.metadata.publication.impact_factor = metrics["impact_factor"]
-                paper.metadata.publication.impact_factor_engines = [
-                    metrics.get("source", "JCR")
-                ]
-                logger.info(
-                    f"{self.name}: Impact factor added: {metrics['impact_factor']} (from {metrics.get('source', 'JCR')})"
-                )
-            else:
-                logger.debug(
-                    f"{self.name}: No impact factor found for journal: {journal}"
-                )
-
-        except Exception as e:
-            logger.debug(f"{self.name}: Impact factor lookup failed: {e}")
-
-
-def main(args):
-    """Run single paper pipeline"""
-
-    pipeline_single = ScholarPipelineSingle(
-        browser_mode=args.browser_mode, chrome_profile=args.chrome_profile
+@stx.session
+def main(
+    doi_or_title: str = None,
+    project: str = None,
+    browser_mode: str = "stealth",
+    chrome_profile: str = "system",
+    force: bool = False,
+    CONFIG=stx.INJECTED,
+    logger=stx.INJECTED,
+) -> int:
+    """Orchestrate full paper acquisition pipeline.
+
+    Parameters
+    ----------
+    doi_or_title : str
+        DOI or paper title (required)
+    project : str
+        Project name for symlinking (optional)
+    browser_mode : str
+        Browser mode: 'stealth' or 'interactive' (default: stealth)
+    chrome_profile : str
+        Chrome profile name (default: system)
+    force : bool
+        Force fresh processing (default: False)
+
+    Returns
+    -------
+    int
+        Exit status code (0 for success)
+    """
+    if not doi_or_title:
+        logger.error("--doi-or-title is required")
+        return 1
+
+    pipeline = ScholarPipelineSingle(
+        browser_mode=browser_mode, chrome_profile=chrome_profile
     )
-
-    # Run pipeline (returns tuple of paper and symlink_path)
     paper, symlink_path = asyncio.run(
-        pipeline_single.process_single_paper(
-            doi_or_title=args.doi_or_title,
-            project=args.project,
-            force=args.force,
+        pipeline.process_single_paper(
+            doi_or_title=doi_or_title,
+            project=project,
+            force=force,
         )
     )
-
     return 0
 
 
-def parse_args() -> argparse.Namespace:
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Orchestrate full paper acquisition pipeline"
-    )
-    parser.add_argument(
-        "--doi-or-title",
-        type=str,
-        required=True,
-        help="DOI or paper title",
-    )
-    parser.add_argument(
-        "--project",
-        type=str,
-        default=None,
-        help="Project name for symlinking (optional)",
-    )
-    parser.add_argument(
-        "--browser-mode",
-        type=str,
-        choices=["stealth", "interactive"],
-        default="stealth",
-        help="Browser mode (default: interactive)",
-    )
-    parser.add_argument(
-        "--chrome-profile",
-        type=str,
-        required=True,
-        # default="system",
-        help="Chrome profile name (default: system, parallel workers: system_worker_0-7)",
-    )
-    parser.add_argument(
-        "--force",
-        "-f",
-        action="store_true",
-        default=False,
-        help="Force fresh processing, ignore existing files",
-    )
-    args = parser.parse_args()
-    return args
-
-
-def run_main() -> None:
-    """Initialize scitex framework, run main function, and cleanup."""
-    global CONFIG, CC, sys, plt, rng
-
-    import sys
-
-    import matplotlib.pyplot as plt
-
-    import scitex as stx
-
-    args = parse_args()
-
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
-        sys,
-        plt,
-        args=args,
-        file=__FILE__,
-        sdir_suffix=None,
-        verbose=False,
-        agg=True,
-    )
-
-    exit_status = main(args)
-
-    stx.session.close(
-        CONFIG,
-        verbose=False,
-        notify=False,
-        message="",
-        exit_status=exit_status,
-    )
-
-
 if __name__ == "__main__":
-    run_main()
-
-"""
-Usage:
-
-
-# With Title
-python -m scitex.scholar.pipelines.ScholarPipelineSingle \
-    --doi-or-title "Epileptic seizure forecasting with long short-term memory (LSTM) neural networks" \
-    --project neurovista \
-    --chrome-profile system \
-    --browser-mode interactive \
-    --force
-
-# With DOI; Neurology; Manual Download required
-python -m scitex.scholar.pipelines.ScholarPipelineSingle \
-    --doi-or-title "10.1212/wnl.0000000000200348" \
-    --project neurovista \
-    --chrome-profile system \
-    --browser-mode interactive
-"""
+    main()
+
+# Usage:
+# python -m scitex.scholar.pipelines.ScholarPipelineSingle \
+#     --doi-or-title "10.1038/nature12373" \
+#     --project test \
+#     --chrome-profile system \
+#     --browser-mode stealth
 
 # EOF