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

scitex/scholar/integration/zotero/linker.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Zotero linker - Live synchronization between Zotero and Scholar library.
+
+Features:
+- Monitor Zotero library for changes
+- Automatically sync new/updated items
+- Live citation insertion
+- Auto-update on library changes
+- Tag-based organization
+"""
+
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Callable
+import json
+
+from scitex import logging
+from scitex.scholar.core.Paper import Paper
+from scitex.scholar.storage import LibraryManager
+from .importer import ZoteroImporter
+from .exporter import ZoteroExporter
+from .mapper import ZoteroMapper
+
+logger = logging.getLogger(__name__)
+
+
+class ZoteroLinker:
+    """Bidirectional live synchronization with Zotero."""
+
+    def __init__(
+        self,
+        library_id: Optional[str] = None,
+        library_type: str = "user",
+        api_key: Optional[str] = None,
+        project: str = "default",
+        config=None,
+        sync_interval: int = 60,  # seconds
+    ):
+        """Initialize Zotero linker.
+
+        Args:
+            library_id: Zotero library ID (user ID or group ID)
+            library_type: 'user' or 'group'
+            api_key: Zotero API key
+            project: Scholar project name
+            config: Optional ScholarConfig instance
+            sync_interval: Seconds between sync checks (default: 60)
+        """
+        self.library_id = library_id
+        self.library_type = library_type
+        self.api_key = api_key
+        self.project = project
+        self.config = config
+        self.sync_interval = sync_interval
+
+        self.importer = ZoteroImporter(
+            library_id=library_id,
+            library_type=library_type,
+            api_key=api_key,
+            project=project,
+            config=config
+        )
+        self.exporter = ZoteroExporter(
+            library_id=library_id,
+            library_type=library_type,
+            api_key=api_key,
+            project=project,
+            config=config
+        )
+        self.mapper = ZoteroMapper(config=config)
+        self.library_manager = LibraryManager(project=project, config=config)
+
+        # State tracking
+        self._last_sync_version = 0
+        self._synced_items: Set[str] = set()  # Zotero item keys
+        self._callbacks: List[Callable] = []
+        self._running = False
+
+    def register_callback(self, callback: Callable[[str, Paper], None]):
+        """Register callback for sync events.
+
+        Callback signature: callback(event_type: str, paper: Paper)
+        Event types: 'added', 'updated', 'deleted'
+
+        Args:
+            callback: Function to call on sync events
+        """
+        self._callbacks.append(callback)
+        logger.info(f"Registered sync callback: {callback.__name__}")
+
+    def start_sync(
+        self,
+        bidirectional: bool = True,
+        auto_import: bool = True,
+        auto_export: bool = False,
+    ):
+        """Start continuous synchronization.
+
+        Args:
+            bidirectional: Sync both directions (Zotero ↔ Scholar)
+            auto_import: Automatically import new Zotero items
+            auto_export: Automatically export new Scholar items
+        """
+        logger.info(
+            f"Starting Zotero sync (interval: {self.sync_interval}s, "
+            f"bidirectional: {bidirectional}, auto_import: {auto_import}, "
+            f"auto_export: {auto_export})"
+        )
+
+        self._running = True
+
+        try:
+            while self._running:
+                try:
+                    # Check for Zotero updates
+                    if auto_import:
+                        self._sync_from_zotero()
+
+                    # Check for Scholar updates
+                    if bidirectional and auto_export:
+                        self._sync_to_zotero()
+
+                    # Wait before next sync
+                    time.sleep(self.sync_interval)
+
+                except KeyboardInterrupt:
+                    logger.info("Sync interrupted by user")
+                    break
+                except Exception as e:
+                    logger.error(f"Sync error: {e}")
+                    time.sleep(self.sync_interval)
+
+        finally:
+            self._running = False
+            logger.info("Stopped Zotero sync")
+
+    def stop_sync(self):
+        """Stop continuous synchronization."""
+        self._running = False
+        logger.info("Stopping Zotero sync...")
+
+    def sync_once(
+        self,
+        bidirectional: bool = True,
+        auto_import: bool = True,
+        auto_export: bool = False,
+    ) -> Dict[str, int]:
+        """Perform single synchronization.
+
+        Args:
+            bidirectional: Sync both directions
+            auto_import: Import new Zotero items
+            auto_export: Export new Scholar items
+
+        Returns:
+            Dict with sync statistics
+        """
+        stats = {
+            "imported": 0,
+            "exported": 0,
+            "updated": 0,
+            "errors": 0
+        }
+
+        try:
+            if auto_import:
+                imported = self._sync_from_zotero()
+                stats["imported"] = imported
+
+            if bidirectional and auto_export:
+                exported = self._sync_to_zotero()
+                stats["exported"] = exported
+
+        except Exception as e:
+            logger.error(f"Sync error: {e}")
+            stats["errors"] += 1
+
+        logger.success(
+            f"Sync complete: {stats['imported']} imported, "
+            f"{stats['exported']} exported, {stats['errors']} errors"
+        )
+
+        return stats
+
+    def _sync_from_zotero(self) -> int:
+        """Sync updates from Zotero to Scholar.
+
+        Returns:
+            Number of items synced
+        """
+        try:
+            zot = self.importer._get_client()
+
+            # Get library version
+            current_version = zot.last_modified_version()
+
+            if current_version <= self._last_sync_version:
+                logger.debug("No Zotero updates since last sync")
+                return 0
+
+            logger.info(
+                f"Zotero library updated (version: {self._last_sync_version} → {current_version})"
+            )
+
+            # Get items modified since last sync
+            items = zot.items(since=self._last_sync_version)
+
+            logger.info(f"Found {len(items)} modified items in Zotero")
+
+            synced_count = 0
+            for item in items:
+                try:
+                    # Skip attachments and notes
+                    if item["data"]["itemType"] in ["attachment", "note"]:
+                        continue
+
+                    item_key = item["key"]
+
+                    # Convert to Paper
+                    paper = self.mapper.zotero_to_paper(item)
+
+                    # Determine if new or updated
+                    event_type = "added" if item_key not in self._synced_items else "updated"
+
+                    # Save to library
+                    paper_id = self.library_manager.save_resolved_paper(
+                        paper_data=paper,
+                        project=self.project
+                    )
+
+                    # Track synced item
+                    self._synced_items.add(item_key)
+                    synced_count += 1
+
+                    # Notify callbacks
+                    for callback in self._callbacks:
+                        try:
+                            callback(event_type, paper)
+                        except Exception as e:
+                            logger.error(f"Callback error: {e}")
+
+                    logger.info(
+                        f"[{event_type}] {paper.metadata.basic.title[:50]}... → {paper_id}"
+                    )
+
+                except Exception as e:
+                    logger.error(f"Failed to sync item {item.get('key')}: {e}")
+                    continue
+
+            # Update last sync version
+            self._last_sync_version = current_version
+
+            logger.success(f"Synced {synced_count} items from Zotero")
+
+            return synced_count
+
+        except Exception as e:
+            logger.error(f"Failed to sync from Zotero: {e}")
+            return 0
+
+    def _sync_to_zotero(self) -> int:
+        """Sync updates from Scholar to Zotero.
+
+        Returns:
+            Number of items synced
+        """
+        # This would require tracking Scholar library changes
+        # Implementation depends on how Scholar tracks modifications
+        logger.info("Scholar → Zotero sync not yet implemented")
+        return 0
+
+    def insert_citation(
+        self,
+        paper: Paper,
+        format: str = "bibtex",
+        style: str = "apa",
+    ) -> str:
+        """Generate formatted citation for a paper.
+
+        Args:
+            paper: Paper object
+            format: Citation format ('bibtex', 'ris', 'text')
+            style: Citation style ('apa', 'mla', 'chicago', etc.)
+
+        Returns:
+            Formatted citation string
+        """
+        if format == "bibtex":
+            # Generate BibTeX entry
+            zotero_item = self.mapper.paper_to_zotero(paper)
+
+            # Create citation key
+            authors = paper.metadata.basic.authors or ["Unknown"]
+            first_author = authors[0].split(",")[0] if authors else "Unknown"
+            year = paper.metadata.basic.year or "NoYear"
+            key = f"{first_author}{year}"
+
+            # Build BibTeX entry
+            lines = [f"@article{{{key},"]
+            lines.append(f"  title = {{{zotero_item.get('title', '')}}},")
+
+            if authors:
+                authors_str = " and ".join(authors)
+                lines.append(f"  author = {{{authors_str}}},")
+
+            if paper.metadata.basic.year:
+                lines.append(f"  year = {{{paper.metadata.basic.year}}},")
+
+            if paper.metadata.publication.journal:
+                lines.append(f"  journal = {{{paper.metadata.publication.journal}}},")
+
+            if paper.metadata.id.doi:
+                lines.append(f"  doi = {{{paper.metadata.id.doi}}},")
+
+            lines.append("}")
+
+            return "\n".join(lines)
+
+        elif format == "ris":
+            # Generate RIS format
+            lines = ["TY  - JOUR"]
+
+            if paper.metadata.basic.title:
+                lines.append(f"TI  - {paper.metadata.basic.title}")
+
+            if paper.metadata.basic.authors:
+                for author in paper.metadata.basic.authors:
+                    lines.append(f"AU  - {author}")
+
+            if paper.metadata.basic.year:
+                lines.append(f"PY  - {paper.metadata.basic.year}")
+
+            if paper.metadata.publication.journal:
+                lines.append(f"JO  - {paper.metadata.publication.journal}")
+
+            if paper.metadata.id.doi:
+                lines.append(f"DO  - {paper.metadata.id.doi}")
+
+            lines.append("ER  - ")
+
+            return "\n".join(lines)
+
+        elif format == "text":
+            # Generate formatted text citation
+            authors = paper.metadata.basic.authors or []
+            year = paper.metadata.basic.year or "n.d."
+            title = paper.metadata.basic.title or "Untitled"
+            journal = paper.metadata.publication.journal or ""
+
+            if style == "apa":
+                # APA format
+                if len(authors) == 0:
+                    author_str = "Unknown"
+                elif len(authors) == 1:
+                    author_str = authors[0]
+                elif len(authors) == 2:
+                    author_str = f"{authors[0]} & {authors[1]}"
+                else:
+                    author_str = f"{authors[0]} et al."
+
+                citation = f"{author_str} ({year}). {title}."
+                if journal:
+                    citation += f" {journal}."
+
+                return citation
+
+            elif style == "mla":
+                # MLA format
+                if authors:
+                    author_str = authors[0]
+                else:
+                    author_str = "Unknown"
+
+                citation = f'{author_str}. "{title}."'
+                if journal:
+                    citation += f" {journal},"
+                citation += f" {year}."
+
+                return citation
+
+            elif style == "chicago":
+                # Chicago format
+                if authors:
+                    author_str = authors[0]
+                else:
+                    author_str = "Unknown"
+
+                citation = f'{author_str}. "{title}."'
+                if journal:
+                    citation += f" {journal}"
+                citation += f" ({year})."
+
+                return citation
+
+        return ""
+
+    def get_sync_status(self) -> Dict[str, Any]:
+        """Get current synchronization status.
+
+        Returns:
+            Dict with sync status information
+        """
+        return {
+            "running": self._running,
+            "last_sync_version": self._last_sync_version,
+            "synced_items_count": len(self._synced_items),
+            "sync_interval": self.sync_interval,
+            "callbacks_registered": len(self._callbacks)
+        }
+
+
+# EOF

scitex/scholar/integration/zotero/mapper.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Zotero ↔ SciTeX Scholar data mapping.
+
+Maps between Zotero's item format and Scholar's Paper format.
+Handles field translations, data normalization, and metadata enrichment.
+"""
+
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+from scitex import logging
+from scitex.scholar.core.Paper import Paper
+
+logger = logging.getLogger(__name__)
+
+
+class ZoteroMapper:
+    """Bidirectional mapping between Zotero and Scholar formats."""
+
+    # Zotero item type mapping to Scholar paper type
+    ZOTERO_TYPE_MAP = {
+        "journalArticle": "article",
+        "conferencePaper": "conference",
+        "preprint": "preprint",
+        "book": "book",
+        "bookSection": "book_chapter",
+        "thesis": "thesis",
+        "report": "report",
+        "webpage": "webpage",
+        "patent": "patent",
+    }
+
+    def __init__(self, config=None):
+        """Initialize mapper.
+
+        Args:
+            config: Optional ScholarConfig instance
+        """
+        self.config = config
+
+    def zotero_to_paper(self, zotero_item: Dict[str, Any]) -> Paper:
+        """Convert Zotero item to Scholar Paper.
+
+        Args:
+            zotero_item: Zotero API item dict with 'data' key
+
+        Returns:
+            Paper object
+        """
+        data = zotero_item.get("data", {})
+
+        paper = Paper()
+
+        # Basic metadata
+        paper.metadata.basic.title = data.get("title", "")
+        paper.metadata.basic.title_engines = ["zotero"]
+
+        # Authors - Zotero format: [{"firstName": "John", "lastName": "Doe", "creatorType": "author"}]
+        creators = data.get("creators", [])
+        authors = []
+        for creator in creators:
+            if creator.get("creatorType") in ["author", "contributor"]:
+                first = creator.get("firstName", "")
+                last = creator.get("lastName", "")
+                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 = ["zotero"]
+
+        # Year - extract from date field
+        date_str = data.get("date", "")
+        if date_str:
+            year = self._extract_year(date_str)
+            if year:
+                paper.metadata.basic.year = year
+                paper.metadata.basic.year_engines = ["zotero"]
+
+        # Abstract
+        abstract = data.get("abstractNote", "")
+        if abstract:
+            paper.metadata.basic.abstract = abstract
+            paper.metadata.basic.abstract_engines = ["zotero"]
+
+        # Keywords/tags - Zotero format: [{"tag": "machine learning", "type": 1}]
+        tags = data.get("tags", [])
+        keywords = [tag.get("tag") for tag in tags if tag.get("tag")]
+        if keywords:
+            paper.metadata.basic.keywords = keywords
+            paper.metadata.basic.keywords_engines = ["zotero"]
+
+        # Paper type
+        item_type = data.get("itemType", "")
+        if item_type:
+            paper_type = self.ZOTERO_TYPE_MAP.get(item_type, "article")
+            paper.metadata.basic.type = paper_type
+            paper.metadata.basic.type_engines = ["zotero"]
+
+        # Identifiers
+        doi = data.get("DOI", "")
+        if doi:
+            paper.metadata.set_doi(doi)
+            paper.metadata.id.doi_engines = ["zotero"]
+
+        # Publication details
+        journal = data.get("publicationTitle", "") or data.get("journalAbbreviation", "")
+        if journal:
+            paper.metadata.publication.journal = journal
+            paper.metadata.publication.journal_engines = ["zotero"]
+
+        volume = data.get("volume", "")
+        if volume:
+            paper.metadata.publication.volume = volume
+            paper.metadata.publication.volume_engines = ["zotero"]
+
+        issue = data.get("issue", "")
+        if issue:
+            paper.metadata.publication.issue = issue
+            paper.metadata.publication.issue_engines = ["zotero"]
+
+        pages = data.get("pages", "")
+        if pages:
+            paper.metadata.publication.pages = pages
+            paper.metadata.publication.pages_engines = ["zotero"]
+
+        publisher = data.get("publisher", "")
+        if publisher:
+            paper.metadata.publication.publisher = publisher
+            paper.metadata.publication.publisher_engines = ["zotero"]
+
+        issn = data.get("ISSN", "")
+        if issn:
+            paper.metadata.publication.issn = issn
+            paper.metadata.publication.issn_engines = ["zotero"]
+
+        # URL
+        url = data.get("url", "")
+        if url:
+            if "doi.org" in url:
+                paper.metadata.url.doi = url
+                paper.metadata.url.doi_engines = ["zotero"]
+            elif "arxiv.org" in url:
+                paper.metadata.url.arxiv = url
+                paper.metadata.url.arxiv_engines = ["zotero"]
+            else:
+                paper.metadata.url.publisher = url
+                paper.metadata.url.publisher_engines = ["zotero"]
+
+        # Container metadata - track Zotero origin
+        paper.container.created_by = "zotero_import"
+        paper.container.created_at = datetime.now().isoformat()
+        paper.container.updated_at = datetime.now().isoformat()
+
+        # Store Zotero-specific metadata
+        paper._zotero_key = zotero_item.get("key", "")
+        paper._zotero_version = zotero_item.get("version", 0)
+        paper._zotero_collections = data.get("collections", [])
+        paper._zotero_extra = data.get("extra", "")
+
+        logger.debug(f"Converted Zotero item '{paper.metadata.basic.title}' to Paper")
+
+        return paper
+
+    def paper_to_zotero(self, paper: Paper) -> Dict[str, Any]:
+        """Convert Scholar Paper to Zotero item format.
+
+        Args:
+            paper: Paper object
+
+        Returns:
+            Dict in Zotero API item format
+        """
+        # Determine Zotero item type from Scholar type
+        paper_type = paper.metadata.basic.type or "article"
+        zotero_type = "journalArticle"  # default
+        for zot_type, scholar_type in self.ZOTERO_TYPE_MAP.items():
+            if scholar_type == paper_type:
+                zotero_type = zot_type
+                break
+
+        # Build creators list
+        creators = []
+        if paper.metadata.basic.authors:
+            for author in paper.metadata.basic.authors:
+                # Parse "Last, First" format
+                parts = author.split(",")
+                if len(parts) == 2:
+                    last_name = parts[0].strip()
+                    first_name = parts[1].strip()
+                    creators.append({
+                        "creatorType": "author",
+                        "firstName": first_name,
+                        "lastName": last_name
+                    })
+                else:
+                    # Single name - treat as lastName
+                    creators.append({
+                        "creatorType": "author",
+                        "lastName": author.strip()
+                    })
+
+        # Build tags list
+        tags = []
+        if paper.metadata.basic.keywords:
+            tags = [{"tag": kw, "type": 1} for kw in paper.metadata.basic.keywords]
+
+        # Build date string
+        date_str = ""
+        if paper.metadata.basic.year:
+            date_str = str(paper.metadata.basic.year)
+
+        # Split pages if needed
+        pages_str = paper.metadata.publication.pages or ""
+
+        # Build Zotero item
+        zotero_item = {
+            "itemType": zotero_type,
+            "title": paper.metadata.basic.title or "",
+            "creators": creators,
+            "abstractNote": paper.metadata.basic.abstract or "",
+            "publicationTitle": paper.metadata.publication.journal or "",
+            "volume": paper.metadata.publication.volume or "",
+            "issue": paper.metadata.publication.issue or "",
+            "pages": pages_str,
+            "date": date_str,
+            "DOI": paper.metadata.id.doi or "",
+            "url": paper.metadata.url.publisher or paper.metadata.url.doi or "",
+            "publisher": paper.metadata.publication.publisher or "",
+            "ISSN": paper.metadata.publication.issn or "",
+            "tags": tags,
+        }
+
+        # Add collections if stored from previous import
+        if hasattr(paper, "_zotero_collections"):
+            zotero_item["collections"] = paper._zotero_collections
+
+        # Add extra field with SciTeX metadata
+        extra_lines = []
+        if hasattr(paper, "_zotero_extra") and paper._zotero_extra:
+            extra_lines.append(paper._zotero_extra)
+
+        # Add SciTeX identifiers to extra field
+        if paper.container.library_id:
+            extra_lines.append(f"SciTeX-ID: {paper.container.library_id}")
+        if paper.metadata.citation_count.total:
+            extra_lines.append(f"Citation-Count: {paper.metadata.citation_count.total}")
+        if paper.metadata.publication.impact_factor:
+            extra_lines.append(f"Impact-Factor: {paper.metadata.publication.impact_factor}")
+
+        if extra_lines:
+            zotero_item["extra"] = "\n".join(extra_lines)
+
+        logger.debug(f"Converted Paper '{paper.metadata.basic.title}' to Zotero item")
+
+        return zotero_item
+
+    def _extract_year(self, date_str: str) -> Optional[int]:
+        """Extract year from various date formats.
+
+        Args:
+            date_str: Date string in various formats
+
+        Returns:
+            Year as int, or None if not found
+        """
+        import re
+
+        # Try to find 4-digit year
+        match = re.search(r'\b(19|20)\d{2}\b', date_str)
+        if match:
+            try:
+                return int(match.group(0))
+            except ValueError:
+                pass
+
+        return None
+
+
+# EOF