scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/scholar/integration/mendeley/importer.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Mendeley importer - Import from Mendeley to Scholar library.
+
+Uses mendeley python SDK: https://github.com/Mendeley/mendeley-python-sdk
+Install: pip install mendeley
+"""
+
+from typing import List, Optional
+import os
+
+from scitex import logging
+from scitex.scholar.core.Papers import Papers
+from ..base import BaseImporter
+from .mapper import MendeleyMapper
+
+logger = logging.getLogger(__name__)
+
+
+class MendeleyImporter(BaseImporter):
+    """Import from Mendeley to Scholar library."""
+
+    def __init__(
+        self,
+        app_id: Optional[str] = None,
+        app_secret: Optional[str] = None,
+        access_token: Optional[str] = None,
+        project: str = "default",
+        config=None,
+    ):
+        """Initialize Mendeley importer.
+
+        Args:
+            app_id: Mendeley app ID
+            app_secret: Mendeley app secret
+            access_token: OAuth access token
+            project: Scholar project name
+            config: Optional ScholarConfig instance
+
+        Get credentials from: https://dev.mendeley.com/myapps.html
+        """
+        credentials = {
+            "app_id": app_id or os.getenv("MENDELEY_APP_ID"),
+            "app_secret": app_secret or os.getenv("MENDELEY_APP_SECRET"),
+            "access_token": access_token or os.getenv("MENDELEY_ACCESS_TOKEN"),
+        }
+
+        super().__init__(credentials=credentials, project=project, config=config)
+
+        self._client = None
+
+    def _create_mapper(self) -> MendeleyMapper:
+        """Create Mendeley mapper."""
+        return MendeleyMapper(config=self.config)
+
+    def _get_client(self):
+        """Get or create Mendeley client."""
+        if self._client is None:
+            try:
+                from mendeley import Mendeley
+
+                mendeley = Mendeley(
+                    client_id=self.credentials["app_id"],
+                    client_secret=self.credentials["app_secret"]
+                )
+
+                if self.credentials.get("access_token"):
+                    # Use existing access token
+                    session = mendeley.start_client_credentials_flow().authenticate()
+                    self._client = session
+                else:
+                    # Start OAuth flow
+                    auth = mendeley.start_authorization_code_flow()
+                    logger.info(f"Please authorize at: {auth.get_login_url()}")
+                    logger.info("Then provide the authorization code")
+                    # This requires interactive input - implement as needed
+
+                logger.info("Connected to Mendeley")
+
+            except ImportError:
+                raise ImportError(
+                    "mendeley SDK not installed. Install with: pip install mendeley"
+                )
+
+        return self._client
+
+    def import_collection(
+        self,
+        collection_id: Optional[str] = None,
+        collection_name: Optional[str] = None,
+        limit: Optional[int] = None,
+        include_pdfs: bool = True,
+        include_annotations: bool = True,
+    ) -> Papers:
+        """Import items from a Mendeley folder.
+
+        Args:
+            collection_id: Folder ID
+            collection_name: Folder name
+            limit: Maximum items to import
+            include_pdfs: Include PDF files
+            include_annotations: Include annotations
+
+        Returns:
+            Papers collection
+        """
+        client = self._get_client()
+
+        # Get folder if specified
+        folder = None
+        if collection_name:
+            folders = client.folders.list()
+            for f in folders.items:
+                if f.name == collection_name:
+                    folder = f
+                    collection_id = f.id
+                    break
+
+        # Get documents
+        if folder:
+            logger.info(f"Importing from folder: {folder.name}")
+            documents = folder.documents.list(limit=limit).items
+        else:
+            logger.info("Importing all documents")
+            documents = client.documents.list(limit=limit).items
+
+        logger.info(f"Retrieved {len(documents)} documents from Mendeley")
+
+        # Convert to Papers
+        papers = []
+        for i, doc in enumerate(documents, 1):
+            try:
+                doc_dict = doc.json
+                paper = self.mapper.external_to_paper(doc_dict)
+
+                # Import files if requested
+                if include_pdfs:
+                    files = doc.files.list().items
+                    for file in files:
+                        if file.mime_type == "application/pdf":
+                            pdf_entry = {
+                                "url": file.file_url,
+                                "source": "mendeley",
+                                "mendeley_file_id": file.id
+                            }
+                            paper.metadata.url.pdfs.append(pdf_entry)
+
+                papers.append(paper)
+
+                logger.info(
+                    f"[{i}/{len(documents)}] Imported: {paper.metadata.basic.title[:50]}..."
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to import document: {e}")
+                continue
+
+        papers_collection = Papers(papers, project=self.project)
+        logger.success(f"Imported {len(papers)} papers from Mendeley")
+
+        return papers_collection
+
+    def import_by_tags(
+        self,
+        tags: List[str],
+        match_all: bool = False,
+        limit: Optional[int] = None,
+        include_pdfs: bool = True,
+        include_annotations: bool = True,
+    ) -> Papers:
+        """Import items with specific tags.
+
+        Args:
+            tags: List of tag names
+            match_all: Require all tags
+            limit: Maximum items
+            include_pdfs: Include PDFs
+            include_annotations: Include annotations
+
+        Returns:
+            Papers collection
+        """
+        client = self._get_client()
+
+        # Search by tags
+        all_docs = client.documents.list(limit=limit).items
+
+        matching_docs = []
+        for doc in all_docs:
+            doc_tags = doc.json.get("tags", [])
+
+            if match_all:
+                if all(tag in doc_tags for tag in tags):
+                    matching_docs.append(doc)
+            else:
+                if any(tag in doc_tags for tag in tags):
+                    matching_docs.append(doc)
+
+        logger.info(f"Found {len(matching_docs)} documents matching tags: {tags}")
+
+        # Convert to Papers
+        papers = []
+        for i, doc in enumerate(matching_docs, 1):
+            try:
+                doc_dict = doc.json
+                paper = self.mapper.external_to_paper(doc_dict)
+
+                if include_pdfs:
+                    files = doc.files.list().items
+                    for file in files:
+                        if file.mime_type == "application/pdf":
+                            pdf_entry = {
+                                "url": file.file_url,
+                                "source": "mendeley",
+                                "mendeley_file_id": file.id
+                            }
+                            paper.metadata.url.pdfs.append(pdf_entry)
+
+                papers.append(paper)
+
+                logger.info(
+                    f"[{i}/{len(matching_docs)}] Imported: {paper.metadata.basic.title[:50]}..."
+                )
+
+            except Exception as e:
+                logger.error(f"Failed to import document: {e}")
+                continue
+
+        papers_collection = Papers(papers, project=self.project)
+        logger.success(f"Imported {len(papers)} papers by tags")
+
+        return papers_collection
+
+
+# EOF

scitex/scholar/integration/mendeley/linker.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Mendeley linker - Live synchronization with Mendeley.
+"""
+
+from typing import Optional
+import os
+
+from scitex import logging
+from ..base import BaseLinker
+from .importer import MendeleyImporter
+from .exporter import MendeleyExporter
+from .mapper import MendeleyMapper
+
+logger = logging.getLogger(__name__)
+
+
+class MendeleyLinker(BaseLinker):
+    """Live synchronization with Mendeley."""
+
+    def __init__(
+        self,
+        app_id: Optional[str] = None,
+        app_secret: Optional[str] = None,
+        access_token: Optional[str] = None,
+        project: str = "default",
+        config=None,
+        sync_interval: int = 60,
+    ):
+        """Initialize Mendeley linker.
+
+        Args:
+            app_id: Mendeley app ID
+            app_secret: Mendeley app secret
+            access_token: OAuth access token
+            project: Scholar project name
+            config: Optional ScholarConfig instance
+            sync_interval: Seconds between syncs
+        """
+        credentials = {
+            "app_id": app_id or os.getenv("MENDELEY_APP_ID"),
+            "app_secret": app_secret or os.getenv("MENDELEY_APP_SECRET"),
+            "access_token": access_token or os.getenv("MENDELEY_ACCESS_TOKEN"),
+        }
+
+        super().__init__(
+            credentials=credentials,
+            project=project,
+            config=config,
+            sync_interval=sync_interval
+        )
+
+    def _create_importer(self) -> MendeleyImporter:
+        """Create importer instance."""
+        return MendeleyImporter(
+            app_id=self.credentials["app_id"],
+            app_secret=self.credentials["app_secret"],
+            access_token=self.credentials["access_token"],
+            project=self.project,
+            config=self.config
+        )
+
+    def _create_exporter(self) -> MendeleyExporter:
+        """Create exporter instance."""
+        return MendeleyExporter(
+            app_id=self.credentials["app_id"],
+            app_secret=self.credentials["app_secret"],
+            access_token=self.credentials["access_token"],
+            project=self.project,
+            config=self.config
+        )
+
+    def _create_mapper(self) -> MendeleyMapper:
+        """Create mapper instance."""
+        return MendeleyMapper(config=self.config)
+
+
+# EOF

scitex/scholar/integration/mendeley/mapper.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Mendeley ↔ Scholar data mapping.
+"""
+
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+from scitex import logging
+from scitex.scholar.core.Paper import Paper
+from ..base import BaseMapper
+
+logger = logging.getLogger(__name__)
+
+
+class MendeleyMapper(BaseMapper):
+    """Mendeley ↔ Scholar data mapping."""
+
+    def external_to_paper(self, item: Dict[str, Any]) -> Paper:
+        """Convert Mendeley document to Scholar Paper.
+
+        Args:
+            item: Mendeley document dict
+
+        Returns:
+            Paper object
+        """
+        paper = Paper()
+
+        # Basic metadata
+        paper.metadata.basic.title = item.get("title", "")
+        paper.metadata.basic.title_engines = ["mendeley"]
+
+        # Authors - Mendeley format: [{"first_name": "John", "last_name": "Doe"}]
+        authors_data = item.get("authors", [])
+        authors = []
+        for author in authors_data:
+            first = author.get("first_name", "")
+            last = author.get("last_name", "")
+            if first and last:
+                authors.append(f"{last}, {first}")
+            elif last:
+                authors.append(last)
+            elif first:
+                authors.append(first)
+
+        if authors:
+            paper.metadata.basic.authors = authors
+            paper.metadata.basic.authors_engines = ["mendeley"]
+
+        # Year
+        year = item.get("year")
+        if year:
+            paper.metadata.basic.year = int(year)
+            paper.metadata.basic.year_engines = ["mendeley"]
+
+        # Abstract
+        abstract = item.get("abstract", "")
+        if abstract:
+            paper.metadata.basic.abstract = abstract
+            paper.metadata.basic.abstract_engines = ["mendeley"]
+
+        # Keywords/tags
+        tags = item.get("tags", [])
+        keywords = item.get("keywords", [])
+        all_keywords = list(set(tags + keywords))
+        if all_keywords:
+            paper.metadata.basic.keywords = all_keywords
+            paper.metadata.basic.keywords_engines = ["mendeley"]
+
+        # Type
+        doc_type = item.get("type", "")
+        if doc_type:
+            paper.metadata.basic.type = doc_type
+            paper.metadata.basic.type_engines = ["mendeley"]
+
+        # Identifiers
+        doi = item.get("identifiers", {}).get("doi", "")
+        if not doi:
+            doi = item.get("doi", "")
+        if doi:
+            paper.metadata.set_doi(doi)
+            paper.metadata.id.doi_engines = ["mendeley"]
+
+        pmid = item.get("identifiers", {}).get("pmid", "")
+        if pmid:
+            paper.metadata.id.pmid = pmid
+            paper.metadata.id.pmid_engines = ["mendeley"]
+
+        # Publication details
+        source = item.get("source", "")
+        if source:
+            paper.metadata.publication.journal = source
+            paper.metadata.publication.journal_engines = ["mendeley"]
+
+        volume = item.get("volume", "")
+        if volume:
+            paper.metadata.publication.volume = volume
+            paper.metadata.publication.volume_engines = ["mendeley"]
+
+        issue = item.get("issue", "")
+        if issue:
+            paper.metadata.publication.issue = issue
+            paper.metadata.publication.issue_engines = ["mendeley"]
+
+        pages = item.get("pages", "")
+        if pages:
+            paper.metadata.publication.pages = pages
+            paper.metadata.publication.pages_engines = ["mendeley"]
+
+        publisher = item.get("publisher", "")
+        if publisher:
+            paper.metadata.publication.publisher = publisher
+            paper.metadata.publication.publisher_engines = ["mendeley"]
+
+        issn = item.get("issn", "")
+        if issn:
+            paper.metadata.publication.issn = issn
+            paper.metadata.publication.issn_engines = ["mendeley"]
+
+        # URLs
+        websites = item.get("websites", [])
+        if websites:
+            url = websites[0]
+            if "doi.org" in url:
+                paper.metadata.url.doi = url
+                paper.metadata.url.doi_engines = ["mendeley"]
+            else:
+                paper.metadata.url.publisher = url
+                paper.metadata.url.publisher_engines = ["mendeley"]
+
+        # Container metadata
+        paper.container.created_by = "mendeley_import"
+        paper.container.created_at = datetime.now().isoformat()
+        paper.container.updated_at = datetime.now().isoformat()
+
+        # Store Mendeley-specific metadata
+        paper._mendeley_id = item.get("id", "")
+        paper._mendeley_group_id = item.get("group_id", "")
+        paper._mendeley_profile_id = item.get("profile_id", "")
+        paper._mendeley_notes = item.get("notes", "")
+
+        logger.debug(f"Converted Mendeley document '{paper.metadata.basic.title}' to Paper")
+
+        return paper
+
+    def paper_to_external(self, paper: Paper) -> Dict[str, Any]:
+        """Convert Scholar Paper to Mendeley document format.
+
+        Args:
+            paper: Paper object
+
+        Returns:
+            Dict in Mendeley format
+        """
+        # Build authors list
+        authors = []
+        if paper.metadata.basic.authors:
+            for author in paper.metadata.basic.authors:
+                parts = author.split(",")
+                if len(parts) == 2:
+                    authors.append({
+                        "first_name": parts[1].strip(),
+                        "last_name": parts[0].strip()
+                    })
+                else:
+                    authors.append({"last_name": author.strip()})
+
+        # Build Mendeley document
+        mendeley_doc = {
+            "type": paper.metadata.basic.type or "journal",
+            "title": paper.metadata.basic.title or "",
+            "authors": authors,
+            "year": paper.metadata.basic.year,
+            "abstract": paper.metadata.basic.abstract or "",
+            "source": paper.metadata.publication.journal or "",
+            "volume": paper.metadata.publication.volume or "",
+            "issue": paper.metadata.publication.issue or "",
+            "pages": paper.metadata.publication.pages or "",
+            "publisher": paper.metadata.publication.publisher or "",
+            "issn": paper.metadata.publication.issn or "",
+            "keywords": paper.metadata.basic.keywords or [],
+            "tags": paper.metadata.basic.keywords or [],
+        }
+
+        # Identifiers
+        identifiers = {}
+        if paper.metadata.id.doi:
+            identifiers["doi"] = paper.metadata.id.doi
+        if paper.metadata.id.pmid:
+            identifiers["pmid"] = paper.metadata.id.pmid
+
+        if identifiers:
+            mendeley_doc["identifiers"] = identifiers
+
+        # URLs
+        websites = []
+        if paper.metadata.url.doi:
+            websites.append(paper.metadata.url.doi)
+        elif paper.metadata.url.publisher:
+            websites.append(paper.metadata.url.publisher)
+
+        if websites:
+            mendeley_doc["websites"] = websites
+
+        logger.debug(f"Converted Paper '{paper.metadata.basic.title}' to Mendeley document")
+
+        return mendeley_doc
+
+
+# EOF

scitex/scholar/integration/zotero/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Zotero integration for SciTeX Scholar module.
+
+This module provides bidirectional integration with Zotero reference manager:
+- Import: Bibliography with collections/tags, PDF annotations, paper metadata
+- Export: Manuscripts as preprint entries, project metadata, citation files (.bib, .ris)
+- Link: Live citation insertion, auto-update on library changes, tagged items
+
+Public API:
+- ZoteroImporter: Import data from Zotero
+- ZoteroExporter: Export data to Zotero
+- ZoteroLinker: Live synchronization with Zotero
+"""
+
+from .importer import ZoteroImporter
+from .exporter import ZoteroExporter
+from .linker import ZoteroLinker
+from .mapper import ZoteroMapper
+
+__all__ = [
+    "ZoteroImporter",
+    "ZoteroExporter",
+    "ZoteroLinker",
+    "ZoteroMapper",
+]