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

scitex/scholar/storage/_mixins/_symlink_handlers.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/storage/_mixins/_symlink_handlers.py
+
+"""
+Symlink handling mixin for LibraryManager.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SymlinkHandlersMixin:
+    """Mixin providing symlink handling methods."""
+
+    def _generate_readable_name(
+        self,
+        comprehensive_metadata: Dict,
+        master_storage_path: Path,
+        authors: Optional[List[str]] = None,
+        year: Optional[int] = None,
+        journal: Optional[str] = None,
+    ) -> str:
+        """Generate readable symlink name from metadata."""
+        from scitex.dict import DotDict
+
+        # Extract author
+        first_author = "Unknown"
+        if authors and len(authors) > 0:
+            author_parts = authors[0].split()
+            first_author = (
+                author_parts[-1] if len(author_parts) > 1 else author_parts[0]
+            )
+            first_author = "".join(c for c in first_author if c.isalnum() or c == "-")[
+                :20
+            ]
+
+        # Format year
+        if isinstance(year, DotDict):
+            year = None
+
+        if isinstance(year, str) and year.isdigit():
+            year = int(year)
+
+        year_str = f"{year:04d}" if isinstance(year, int) else "0000"
+
+        # Clean journal name
+        journal_clean = "Unknown"
+        if journal:
+            journal_clean = self.config.path_manager._sanitize_filename(journal)[:30]
+            if not journal_clean:
+                journal_clean = "Unknown"
+
+        # Get citation count and impact factor
+        cc, if_val = self._extract_cc_and_if(comprehensive_metadata)
+
+        # Count PDFs
+        pdf_files = list(master_storage_path.glob("*.pdf"))
+        n_pdfs = len(pdf_files)
+
+        readable_name = f"PDF-{n_pdfs:02d}_CC-{cc:06d}_IF-{int(if_val):03d}_{year_str}_{first_author}_{journal_clean}"
+        return readable_name
+
+    def _extract_cc_and_if(self, comprehensive_metadata: Dict) -> tuple:
+        """Extract citation count and impact factor from metadata."""
+        if "metadata" in comprehensive_metadata:
+            metadata_section = comprehensive_metadata.get("metadata", {})
+            cc_val = metadata_section.get("citation_count", {})
+            if isinstance(cc_val, dict):
+                cc = cc_val.get("total", 0) or 0
+            else:
+                cc = cc_val or 0
+
+            publication_section = metadata_section.get("publication", {})
+            if_val = publication_section.get("impact_factor", 0.0) or 0.0
+        else:
+            cc_val = comprehensive_metadata.get("citation_count", 0)
+            if isinstance(cc_val, dict):
+                cc = cc_val.get("total", 0) or 0
+            else:
+                cc = cc_val or 0
+
+            if_val = (
+                comprehensive_metadata.get("journal_impact_factor")
+                or comprehensive_metadata.get("impact_factor")
+                or comprehensive_metadata.get("publication", {}).get("impact_factor")
+            )
+            if isinstance(if_val, dict):
+                if_val = if_val.get("value", 0.0) or 0.0
+            else:
+                if_val = if_val or 0.0
+
+        return cc, if_val
+
+    def update_symlink(
+        self,
+        master_storage_path: Path,
+        project: str,
+        metadata: Optional[Dict] = None,
+    ) -> Optional[Path]:
+        """Update project symlink to reflect current paper status."""
+        try:
+            if metadata is None:
+                metadata_file = master_storage_path / "metadata.json"
+                if metadata_file.exists():
+                    with open(metadata_file) as f:
+                        metadata = json.load(f)
+                else:
+                    logger.warning(f"No metadata found for {master_storage_path.name}")
+                    return None
+
+            # Extract metadata from nested structure if needed
+            if "metadata" in metadata:
+                meta_section = metadata.get("metadata", {})
+                basic_section = meta_section.get("basic", {})
+                pub_section = meta_section.get("publication", {})
+                authors = basic_section.get("authors")
+                year = basic_section.get("year")
+                journal = pub_section.get("journal")
+            else:
+                authors = metadata.get("authors")
+                year = metadata.get("year")
+                journal = metadata.get("journal")
+
+            readable_name = self._generate_readable_name(
+                comprehensive_metadata=metadata,
+                master_storage_path=master_storage_path,
+                authors=authors,
+                year=year,
+                journal=journal,
+            )
+
+            return self._create_project_symlink(
+                master_storage_path=master_storage_path,
+                project=project,
+                readable_name=readable_name,
+            )
+        except Exception as exc_:
+            logger.error(
+                f"Failed to update symlink for {master_storage_path.name}: {exc_}"
+            )
+            return None
+
+    def _create_project_symlink(
+        self, master_storage_path: Path, project: str, readable_name: str
+    ) -> Optional[Path]:
+        """Create symlink in project directory pointing to master storage."""
+        try:
+            project_dir = self.config.path_manager.get_library_project_dir(project)
+            symlink_path = project_dir / readable_name
+            master_id = master_storage_path.name
+
+            # Remove old symlinks pointing to the same master entry
+            for existing_link in project_dir.iterdir():
+                if not existing_link.is_symlink():
+                    continue
+
+                try:
+                    target = existing_link.resolve()
+                    if target.name == master_id and existing_link.name != readable_name:
+                        logger.debug(f"Removing old symlink: {existing_link.name}")
+                        existing_link.unlink()
+                except Exception as e:
+                    logger.debug(f"Skipping broken symlink {existing_link.name}: {e}")
+                    continue
+
+            # Create new symlink
+            if not symlink_path.exists():
+                relative_path = os.path.relpath(master_storage_path, project_dir)
+                symlink_path.symlink_to(relative_path)
+                logger.success(
+                    f"Created project symlink: {symlink_path} -> {relative_path}"
+                )
+            else:
+                logger.debug(f"Project symlink already exists: {symlink_path}")
+
+            return symlink_path
+
+        except Exception as exc_:
+            logger.warning(f"Failed to create project symlink: {exc_}")
+            return None
+
+    def _ensure_project_symlink(
+        self,
+        title: str,
+        year: Optional[int] = None,
+        authors: Optional[List[str]] = None,
+        paper_id: str = None,
+        master_storage_path: Path = None,
+    ) -> None:
+        """Ensure project symlink exists for paper in master library."""
+        try:
+            if not paper_id or not master_storage_path:
+                return
+
+            project_lib_path = (
+                self.config.path_manager.get_scholar_library_path() / self.project
+            )
+            project_lib_path.mkdir(parents=True, exist_ok=True)
+
+            paper_info = {"title": title, "year": year, "authors": authors or []}
+            readable_paths = self._call_path_manager_get_storage_paths(
+                paper_info=paper_info, collection_name=self.project
+            )
+            readable_name = readable_paths["readable_name"]
+            symlink_path = project_lib_path / readable_name
+            relative_path = f"../MASTER/{paper_id}"
+
+            if not symlink_path.exists():
+                symlink_path.symlink_to(relative_path)
+                logger.info(
+                    f"Created project symlink: {readable_name} -> {relative_path}"
+                )
+        except Exception as exc_:
+            logger.debug(f"Error creating project symlink: {exc_}")
+
+
+# EOF

scitex/scholar/url_finder/translators/individual/cell_press.py

@@ -1,15 +1,31 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Cell Press translator."""
+"""Cell Press translator.
+
+Based on Zotero Cell Press translator by Michael Berkowitz, Sebastian Karcher,
+and Aurimas Vinckevicius.
+
+Cell Press journals include: Cell, Neuron, Immunity, Molecular Cell, etc.
+"""
 
 import re
 from typing import List
+
 from playwright.async_api import Page
+
 from ..core.base import BaseTranslator
 
 
 class CellPressTranslator(BaseTranslator):
-    """Cell Press."""
+    """Cell Press PDF URL extractor.
+
+    Handles journals from cell.com including:
+    - Cell, Neuron, Immunity, Current Biology, etc.
+
+    Strategy:
+    1. Look for citation_pdf_url meta tag
+    2. Look for direct PDF download links
+    3. Construct PDF URL from article URL pattern
+    """
 
     LABEL = "Cell Press"
     URL_TARGET_PATTERN = r"^https?://([a-zA-Z0-9-]+\.)?cell\.com(/.*)?$"
@@ -20,4 +36,115 @@ class CellPressTranslator(BaseTranslator):
 
     @classmethod
     async def extract_pdf_urls_async(cls, page: Page) -> List[str]:
-        return []
+        """Extract PDF URLs from Cell Press pages.
+
+        Args:
+            page: Playwright Page object on a cell.com article page
+
+        Returns:
+            List of PDF URL strings
+        """
+        pdf_urls = []
+        current_url = page.url
+
+        # Strategy 1: Look for citation_pdf_url meta tag
+        try:
+            pdf_meta = await page.evaluate("""
+                () => {
+                    const meta = document.querySelector('meta[name="citation_pdf_url"]');
+                    return meta ? meta.getAttribute('content') : null;
+                }
+            """)
+            if pdf_meta:
+                pdf_urls.append(pdf_meta)
+        except Exception:
+            pass
+
+        # Strategy 2: Look for PDF download links on the page
+        try:
+            pdf_links = await page.evaluate("""
+                () => {
+                    const links = [];
+                    // Look for PDF download buttons/links
+                    const selectors = [
+                        'a[href*="/pdf/"]',
+                        'a[href*=".pdf"]',
+                        'a.article-tools__item--pdf',
+                        'a[data-action="download-pdf"]',
+                        'a[title*="PDF"]',
+                        'a.pdfLink',
+                        'a[href*="pdfft"]',
+                    ];
+                    for (const selector of selectors) {
+                        document.querySelectorAll(selector).forEach(el => {
+                            const href = el.getAttribute('href');
+                            if (href && !links.includes(href)) {
+                                links.push(href);
+                            }
+                        });
+                    }
+                    return links;
+                }
+            """)
+            for link in pdf_links or []:
+                # Make absolute URL if relative
+                if link.startswith("/"):
+                    link = f"https://www.cell.com{link}"
+                if link not in pdf_urls:
+                    pdf_urls.append(link)
+        except Exception:
+            pass
+
+        # Strategy 3: Construct PDF URL from article URL pattern
+        # Cell Press URLs: https://www.cell.com/{journal}/fulltext/{article-id}
+        # PDF URLs: https://www.cell.com/{journal}/pdf/{article-id}.pdf
+        try:
+            fulltext_match = re.search(
+                r"cell\.com/([^/]+)/fulltext/(S[\d-]+\(\d+\)[\d-]+)", current_url
+            )
+            if fulltext_match:
+                journal = fulltext_match.group(1)
+                article_id = fulltext_match.group(2)
+                constructed_pdf = f"https://www.cell.com/{journal}/pdf/{article_id}.pdf"
+                if constructed_pdf not in pdf_urls:
+                    pdf_urls.append(constructed_pdf)
+
+            # Alternative pattern: /pii/ URLs
+            pii_match = re.search(r"cell\.com/([^/]+)/pii/(S[\d]+)", current_url)
+            if pii_match:
+                journal = pii_match.group(1)
+                pii = pii_match.group(2)
+                constructed_pdf = f"https://www.cell.com/{journal}/pdf/{pii}.pdf"
+                if constructed_pdf not in pdf_urls:
+                    pdf_urls.append(constructed_pdf)
+        except Exception:
+            pass
+
+        # Strategy 4: Look for ScienceDirect-style PDF links
+        # Cell Press uses ScienceDirect backend
+        try:
+            sd_links = await page.evaluate("""
+                () => {
+                    const links = [];
+                    // ScienceDirect PDF patterns
+                    document.querySelectorAll('a[href*="sciencedirect"]').forEach(el => {
+                        const href = el.getAttribute('href');
+                        if (href && href.includes('pdf')) {
+                            links.push(href);
+                        }
+                    });
+                    // Look for pdfft (PDF full text) links
+                    document.querySelectorAll('a[href*="pdfft"]').forEach(el => {
+                        const href = el.getAttribute('href');
+                        if (href) links.push(href);
+                    });
+                    return links;
+                }
+            """)
+            for link in sd_links or []:
+                if link not in pdf_urls:
+                    pdf_urls.append(link)
+        except Exception:
+            pass
+
+        return pdf_urls

scitex/security/README.md

@@ -14,7 +14,7 @@ Reusable security utilities for the SciTeX ecosystem. Works everywhere: local, c
 The module is part of the `scitex` package (editable install):
 
 ```bash
-cd ~/proj/scitex-code
+cd ~/proj/scitex-python
 pip install -e .
 ```
 
@@ -162,7 +162,7 @@ Total open alerts: 2
 ```yaml
 - name: Check Security
   run: |
-    pip install -e ~/proj/scitex-code
+    pip install -e ~/proj/scitex-python
     python -m scitex.security.cli check --save
 ```
 
@@ -245,7 +245,7 @@ Get path to latest alerts file.
 ## Testing
 
 ```bash
-cd ~/proj/scitex-code
+cd ~/proj/scitex-python
 pytest tests/test_security.py
 ```
 

scitex/security/__init__.py

@@ -32,4 +32,3 @@ __all__ = [
     "GitHubSecurityError",
 ]
 
-__version__ = "0.1.0"

scitex/session/README.md

@@ -1,7 +1,7 @@
 <!-- ---
 !-- Timestamp: 2025-11-18 10:14:48
 !-- Author: ywatanabe
-!-- File: /home/ywatanabe/proj/scitex-code/src/scitex/session/README.md
+!-- File: /home/ywatanabe/proj/scitex-python/src/scitex/session/README.md
 !-- --- -->
 
 # scitex.session

scitex/sh/README.md

@@ -1,7 +1,7 @@
 <!-- ---
 !-- Timestamp: 2025-10-29 07:23:56
 !-- Author: ywatanabe
-!-- File: /home/ywatanabe/proj/scitex-code/src/scitex/sh/README.md
+!-- File: /home/ywatanabe/proj/scitex-python/src/scitex/sh/README.md
 !-- --- -->
 
 # scitex.sh - Shell Command Execution Module

scitex/social/__init__.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-22
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/social/__init__.py
+
+"""SciTeX Social - Unified social media management.
+
+This module provides a thin wrapper around socialia, the core social media
+integration package. It uses scitex branding and environment variable prefixes.
+
+Features
+--------
+- Twitter/X posting and analytics
+- LinkedIn posting
+- Reddit posting
+- YouTube analytics
+- Google Analytics integration
+
+Environment Variables
+---------------------
+Credentials use SCITEX_ prefix (falls back to SOCIALIA_):
+- SCITEX_X_CONSUMER_KEY, SCITEX_X_CONSUMER_SECRET
+- SCITEX_X_ACCESS_TOKEN, SCITEX_X_ACCESS_TOKEN_SECRET
+- SCITEX_LINKEDIN_ACCESS_TOKEN
+- SCITEX_REDDIT_CLIENT_ID, SCITEX_REDDIT_CLIENT_SECRET
+- SCITEX_YOUTUBE_API_KEY
+- SCITEX_GA_PROPERTY_ID
+
+Usage
+-----
+    import scitex as stx
+
+    # Twitter/X
+    x = stx.social.Twitter()
+    x.post("Hello from SciTeX!")
+
+    # LinkedIn
+    linkedin = stx.social.LinkedIn()
+    linkedin.post("Research update", visibility="public")
+
+    # YouTube analytics
+    yt = stx.social.YouTube()
+    stats = yt.get_channel_stats()
+
+    # Google Analytics
+    ga = stx.social.GoogleAnalytics()
+    report = ga.get_report(start_date="7daysAgo")
+
+See Also
+--------
+- socialia: https://github.com/ywatanabe1989/socialia
+- scitex: https://scitex.ai
+"""
+
+import os as _os
+
+# Set branding BEFORE importing socialia
+_os.environ.setdefault("SOCIALIA_BRAND", "scitex.social")
+_os.environ.setdefault("SOCIALIA_ENV_PREFIX", "SCITEX")
+
+# Check socialia availability
+try:
+    import socialia as _socialia
+
+    # Re-export platform clients
+    from socialia import (
+        # Content strategies for MCP
+        PLATFORM_STRATEGIES,
+        # Base class
+        BasePoster,
+        GoogleAnalytics,
+        LinkedIn,
+        LinkedInPoster,
+        Reddit,
+        RedditPoster,
+        # Platform clients (preferred names)
+        Twitter,
+        # Backward compatibility aliases
+        TwitterPoster,
+        YouTube,
+        YouTubePoster,
+    )
+    from socialia import __version__ as _socialia_version
+
+    SOCIALIA_AVAILABLE = True
+    __socialia_version__ = _socialia_version
+
+except ImportError:
+    SOCIALIA_AVAILABLE = False
+    __socialia_version__ = None
+
+    # Provide helpful error on access
+    class _SocialiaNotAvailable:
+        """Placeholder when socialia is not installed."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "socialia is required for scitex.social. "
+                "Install with: pip install socialia"
+            )
+
+        def __getattr__(self, name):
+            raise ImportError(
+                "socialia is required for scitex.social. "
+                "Install with: pip install socialia"
+            )
+
+    BasePoster = _SocialiaNotAvailable
+    Twitter = _SocialiaNotAvailable
+    LinkedIn = _SocialiaNotAvailable
+    Reddit = _SocialiaNotAvailable
+    YouTube = _SocialiaNotAvailable
+    GoogleAnalytics = _SocialiaNotAvailable
+    TwitterPoster = _SocialiaNotAvailable
+    LinkedInPoster = _SocialiaNotAvailable
+    RedditPoster = _SocialiaNotAvailable
+    YouTubePoster = _SocialiaNotAvailable
+    PLATFORM_STRATEGIES = ""
+
+
+def has_socialia() -> bool:
+    """Check if socialia is available.
+
+    Returns
+    -------
+    bool
+        True if socialia is installed and importable.
+    """
+    return SOCIALIA_AVAILABLE
+
+
+__all__ = [
+    # Availability check
+    "SOCIALIA_AVAILABLE",
+    "has_socialia",
+    "__socialia_version__",
+    # Base class
+    "BasePoster",
+    # Platform clients (preferred names)
+    "Twitter",
+    "LinkedIn",
+    "Reddit",
+    "YouTube",
+    "GoogleAnalytics",
+    # Backward compatibility aliases
+    "TwitterPoster",
+    "LinkedInPoster",
+    "RedditPoster",
+    "YouTubePoster",
+    # Content strategies
+    "PLATFORM_STRATEGIES",
+]
+
+# EOF