scholarcli 1.15__tar.gz → 1.20__tar.gz

{scholarcli-1.15/src/scholarcli.egg-info → scholarcli-1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scholarcli
-Version: 1.15
+Version: 1.20
 Summary: A tool for structured literature searches across bibliographic databases
 Author-email: Daniel Bosk <dbosk@kth.se>, Ric Glassey <glassey@kth.se>
 License-Expression: MIT

{scholarcli-1.15 → scholarcli-1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scholarcli"
-version = "1.15"
+version = "1.20"
 description = "A tool for structured literature searches across bibliographic databases"
 authors = [{ name = "Daniel Bosk", email = "dbosk@kth.se" },
            { name = "Ric Glassey", email = "glassey@kth.se" }]

{scholarcli-1.15 → scholarcli-1.20}/src/scholar/cli.py

@@ -1083,6 +1083,11 @@ def providers() -> None:
             "env_var": "IEEE_API_KEY",
             "how_to_get": "developer.ieee.org",
         },
+        "scopus": {
+            "required": True,
+            "env_var": "SCOPUS_API_KEY",
+            "how_to_get": "dev.elsevier.com",
+        },
     }
 
     for provider in get_all_providers():
@@ -1181,6 +1186,14 @@ def syntax() -> None:
         "[green]✓[/]",
         "Must be UPPERCASE, supports ONEAR",
     )
+    table.add_row(
+        "scopus",
+        "[green]✓[/]",
+        "[green]✓[/]",
+        "[green]✓[/]",
+        "[green]✓[/]",
+        "Must be UPPERCASE, supports W/n PRE/n proximity",
+    )
     table.add_row(
         "arxiv",
         "[green]✓[/]",
@@ -1236,6 +1249,13 @@ def syntax() -> None:
         "[green]✓[/]",
         "Max 5 wildcards per search",
     )
+    table2.add_row(
+        "scopus",
+        "[green]✓[/] * ?",
+        '[green]✓[/] "..."',
+        "[green]✓[/] TITLE() AUTH()",
+        "TITLE-ABS-KEY(), AUTH(), SRCTITLE()",
+    )
     table2.add_row(
         "arxiv",
         "[red]✗[/]",
@@ -1255,6 +1275,7 @@ def syntax() -> None:
         ("dblp", "machine learning privacy  [space = AND]"),
         ("wos", 'TS=("machine learning" AND privacy)'),
         ("ieee", '"machine learning" AND privacy NOT survey'),
+        ("scopus", 'TITLE-ABS-KEY("machine learning" AND privacy)'),
         ("arxiv", 'ti:"machine learning" AND cat:cs.AI'),
     ]
     for provider, example in examples:
@@ -1284,6 +1305,7 @@ def syntax() -> None:
             "ieee",
             "https://ieeexplore.ieee.org/Xplorehelp/searching-ieee-xplore/command-search",
         ),
+        ("scopus", "https://dev.elsevier.com/sc_search_tips.html"),
         (
             "arxiv",
             "https://info.arxiv.org/help/api/user-manual.html#query_details",
@@ -2038,7 +2060,7 @@ def sessions_show(
                 con.print()
 
             # Show kept papers
-            kept = session.kept_papers
+            kept = session.kept_papers()
             if kept:
                 con.print(f"[green bold]Kept ({len(kept)}):[/green bold]")
                 for d in kept:
@@ -2055,7 +2077,7 @@ def sessions_show(
                 con.print()
 
             # Show discarded papers
-            discarded = session.discarded_papers
+            discarded = session.discarded_papers()
             if discarded:
                 con.print(
                     f"[red bold]Discarded ({len(discarded)}):[/red bold]"
@@ -2074,7 +2096,7 @@ def sessions_show(
                 con.print()
 
             # Show pending papers
-            pending = session.pending_papers
+            pending = session.pending_papers()
             if pending:
                 con.print(
                     f"[yellow bold]Pending ({len(pending)}):[/yellow bold]"
@@ -2543,15 +2565,25 @@ def llm_classify(
             help="Skip automatic enrichment of papers without abstracts.",
         ),
     ] = False,
+    no_examples: Annotated[
+        bool,
+        typer.Option(
+            "--no-examples",
+            help="Run without requiring tagged examples (zero-shot).",
+        ),
+    ] = False,
 ) -> None:
     """
     Classify pending papers using LLM.
 
     Uses human-reviewed papers as training examples. Requires at least
-    5 tagged examples (minimum 1 kept, 1 discarded) before classification.
+    5 tagged examples (minimum 1 kept, 1 discarded) unless --no-examples
+    is given, which runs zero-shot classification using only the research
+    context.
 
     Example:
         scholar llm classify "my review" --count 20
+        scholar llm classify "my review" --no-examples
     """
     import scholar.review as review
     from scholar.review import save_session
@@ -2582,6 +2614,7 @@ def llm_classify(
             model_id=select_model_id(model_selection, "analytic"),
             enrich_missing=not no_enrich,
             dry_run=dry_run,
+            require_examples=not no_examples,
         )
 
         if dry_run:

{scholarcli-1.15 → scholarcli-1.20}/src/scholar/providers.py

@@ -43,6 +43,7 @@ WOS_STARTER_API_URL = (
 WOS_EXPANDED_API_URL = "https://wos-api.clarivate.com/api/wos"
 _WOS_NOT_PROVIDED = object()  # Sentinel for "argument not passed"
 IEEE_API_URL = "https://ieeexploreapi.ieee.org/api/v1/search/articles"
+SCOPUS_API_URL = "https://api.elsevier.com/content/search/scopus"
 
 
 class SearchProvider(Protocol):
@@ -1683,6 +1684,8 @@ class WebOfScienceProvider:
             "p",
             default=None,
         )
+        if isinstance(abstract, list):
+            abstract = "\n\n".join(str(p) for p in abstract if p) or None
 
         # Extract venue (source title)
         venue = None
@@ -2787,3 +2790,253 @@ class ArxivProvider:
 
 # Register the provider on module import
 register_provider(ArxivProvider())
+
+
+class ScopusProvider:
+    """Search provider for Elsevier Scopus."""
+
+    name = "scopus"
+    MAX_LIMIT = 25  # Scopus returns max 25 per page
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        inst_token: str | None = None,
+    ):
+        """Initialize the Scopus provider.
+
+        Args:
+            api_key: API key for Scopus API. Falls back
+                to SCOPUS_API_KEY environment variable.
+            inst_token: Institutional token for extended
+                access. Falls back to SCOPUS_INST_TOKEN.
+        """
+        self.api_key = api_key or os.environ.get("SCOPUS_API_KEY")
+        self.inst_token = inst_token or os.environ.get("SCOPUS_INST_TOKEN")
+        self._cache: dict = load_cache(self.name)
+        register_cache(self.name, self._cache)
+
+    def is_available(self) -> bool:
+        """Scopus requires an API key."""
+        return bool(self.api_key)
+
+    @cachedmethod(
+        lambda self: self._cache,
+        key=lambda self, query, limit=100, filters=None: (
+            query,
+            limit,
+            filters.cache_key() if filters else "",
+        ),
+    )
+    def search(
+        self,
+        query: str,
+        limit: int = 100,
+        filters: SearchFilters | None = None,
+    ) -> list[Paper]:
+        """Search Scopus for papers matching the query.
+
+        Fetches multiple pages when the requested limit
+        exceeds the per-request maximum of 25 results.
+        """
+        if not self.api_key:
+            return []
+
+        logger.debug(
+            "scopus: Searching for '%s' with limit=%d",
+            query,
+            limit,
+        )
+
+        search_query = query
+        if filters:
+            clauses = []
+
+            if filters.year:
+                start_year, end_year = filters.year_range()
+                if start_year and end_year:
+                    if start_year == end_year:
+                        clauses.append(f"PUBYEAR = {start_year}")
+                    else:
+                        clauses.append(
+                            f"PUBYEAR > {start_year - 1} "
+                            f"AND PUBYEAR < {end_year + 1}"
+                        )
+                elif start_year:
+                    clauses.append(f"PUBYEAR > {start_year - 1}")
+                elif end_year:
+                    clauses.append(f"PUBYEAR < {end_year + 1}")
+
+            if filters.open_access:
+                clauses.append("OPENACCESS(1)")
+
+            if filters.venue:
+                clauses.append(f"SRCTITLE({filters.venue})")
+
+            if filters.pub_types:
+                type_mapping = {
+                    "article": "ar",
+                    "conference": "cp",
+                    "review": "re",
+                    "book": "bk",
+                }
+                doc_types = []
+                for pt in filters.pub_types:
+                    mapped = type_mapping.get(pt.lower())
+                    if mapped:
+                        doc_types.append(mapped)
+                    else:
+                        logger.warning(
+                            "scopus: Publication type '%s' "
+                            "not supported, ignoring",
+                            pt,
+                        )
+                if doc_types:
+                    dtype_clause = " OR ".join(
+                        f"DOCTYPE({dt})" for dt in doc_types
+                    )
+                    clauses.append(f"({dtype_clause})")
+
+            if filters.min_citations is not None:
+                logger.warning(
+                    "scopus: Citation count filter " "not supported, ignoring"
+                )
+
+            if clauses:
+                search_query = f"({query}) AND " + " AND ".join(clauses)
+
+        all_papers: list[Paper] = []
+        start = 0
+        page_size = self.MAX_LIMIT
+
+        try:
+            while len(all_papers) < limit:
+                remaining = limit - len(all_papers)
+                current_count = min(page_size, remaining)
+
+                headers = {
+                    "X-ELS-APIKey": self.api_key,
+                    "Accept": "application/json",
+                }
+                if self.inst_token:
+                    headers["X-ELS-Insttoken"] = self.inst_token
+
+                params = {
+                    "query": search_query,
+                    "start": start,
+                    "count": current_count,
+                }
+
+                response = requests.get(
+                    SCOPUS_API_URL,
+                    headers=headers,
+                    params=params,
+                    timeout=30,
+                )
+                if response.status_code != 200:
+                    if response.status_code == 401:
+                        logger.warning(
+                            "scopus: Authentication failed (HTTP 401). "
+                            "Check your SCOPUS_API_KEY at "
+                            "https://dev.elsevier.com/"
+                        )
+                    elif response.status_code == 429:
+                        logger.warning(
+                            "scopus: Rate limited (HTTP 429). "
+                            "Wait before making more requests."
+                        )
+                    elif response.status_code == 403:
+                        logger.warning(
+                            "scopus: Access denied (HTTP 403). "
+                            "Your API key may lack Scopus Search "
+                            "permissions."
+                        )
+                    else:
+                        logger.warning(
+                            "scopus: API error (HTTP %d): %s",
+                            response.status_code,
+                            response.text[:200],
+                        )
+                    response.raise_for_status()
+                data = response.json()
+
+                results = data.get("search-results", {})
+                entries = results.get("entry", [])
+
+                if not entries or (
+                    len(entries) == 1 and entries[0].get("@_fa") == "false"
+                ):
+                    break
+
+                all_papers.extend(
+                    self._convert_entry(entry)
+                    for entry in entries
+                    if entry.get("@_fa") != "false"
+                )
+                start += len(entries)
+
+                total = int(results.get("opensearch:totalResults", 0))
+                if start >= total:
+                    break
+
+            logger.debug(
+                "scopus: Retrieved %d papers",
+                len(all_papers),
+            )
+            return all_papers
+        except requests.exceptions.HTTPError:
+            return all_papers
+        except Exception as e:
+            logger.warning("scopus: %s", e)
+            return all_papers
+
+    def _convert_entry(self, entry: dict) -> Paper:
+        """Convert a Scopus search entry to a Paper."""
+        year = None
+        cover_date = entry.get("prism:coverDate")
+        if cover_date:
+            try:
+                year = int(cover_date[:4])
+            except (ValueError, TypeError):
+                pass
+
+        authors = []
+        creator = entry.get("dc:creator")
+        if creator:
+            authors.append(creator)
+
+        url = None
+        for link in entry.get("link", []):
+            if link.get("@ref") == "scopus":
+                url = link.get("@href")
+                break
+
+        keywords = None
+        auth_kw = entry.get("authkeywords")
+        if auth_kw and isinstance(auth_kw, str):
+            keywords = [kw.strip() for kw in auth_kw.split("|") if kw.strip()]
+
+        citation_count = None
+        cited_by = entry.get("citedby-count")
+        if cited_by is not None:
+            try:
+                citation_count = int(cited_by)
+            except (ValueError, TypeError):
+                pass
+
+        return Paper(
+            title=entry.get("dc:title", "") or "",
+            authors=authors,
+            year=year,
+            doi=entry.get("prism:doi"),
+            abstract=entry.get("dc:description"),
+            venue=entry.get("prism:publicationName"),
+            url=url,
+            citation_count=citation_count,
+            keywords=keywords,
+            sources=[self.name],
+        )
+
+
+# Register the provider on module import
+register_provider(ScopusProvider())

{scholarcli-1.15 → scholarcli-1.20}/src/scholar/tui.py

@@ -153,6 +153,18 @@ class PaperListItem(ListItem):
         )
 
 
+def normalize_abstract(abstract) -> str:
+    """Return abstract as a plain string, joining list paragraphs if needed.
+
+    Some providers return the abstract as a list of paragraph strings.
+    This helper joins them with blank lines so paragraph breaks are
+    preserved in the TUI display.
+    """
+    if isinstance(abstract, list):
+        return "\n\n".join(str(p) for p in abstract if p)
+    return abstract or ""
+
+
 class AbstractScreen(Screen[None]):
     """Full-screen view of a paper's abstract and details."""
 
@@ -217,7 +229,7 @@ class AbstractScreen(Screen[None]):
             yield Static("")
             yield Static("[bold]Abstract:[/bold]")
             if paper.abstract:
-                yield Static(escape(paper.abstract))
+                yield Static(escape(normalize_abstract(paper.abstract)))
             else:
                 if paper.pdf_url:
                     yield Static(

{scholarcli-1.15 → scholarcli-1.20/src/scholarcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scholarcli
-Version: 1.15
+Version: 1.20
 Summary: A tool for structured literature searches across bibliographic databases
 Author-email: Daniel Bosk <dbosk@kth.se>, Ric Glassey <glassey@kth.se>
 License-Expression: MIT

{scholarcli-1.15 → scholarcli-1.20}/src/scholarcli.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/snowball/__init__.py
 src/snowball/cli.py
 src/snowball/models.py
 src/snowball/paper_utils.py
+src/snowball/services.py
 src/snowball/snowballing.py
 src/snowball/visualization.py
 src/snowball/apis/__init__.py
@@ -52,6 +53,8 @@ src/snowball/storage/__init__.py
 src/snowball/storage/json_storage.py
 src/snowball/tui/__init__.py
 src/snowball/tui/app.py
+src/snowball/tui/dialogs.py
+src/snowball/tui/setup.py
 src/tuxedo/__init__.py
 src/tuxedo/analysis.py
 src/tuxedo/cli.py

{scholarcli-1.15 → scholarcli-1.20}/src/snowball/apis/aggregator.py

@@ -206,7 +206,7 @@ class APIAggregator:
         if "google_scholar" in self.clients and paper.title:
             try:
                 # Google Scholar returns dicts, convert to Paper objects
-                gs_limit = min(limit, 50)  # Limit GS to 50 due to rate limiting
+                gs_limit = min(limit, 20)  # Keep Scholar fallback batches deliberately small.
                 gs_citations = self.clients["google_scholar"].get_citations(
                     paper.title, gs_limit
                 )

{scholarcli-1.15 → scholarcli-1.20}/src/snowball/apis/google_scholar.py

@@ -6,6 +6,8 @@ from typing import Optional, Tuple, List
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_RATE_LIMIT_DELAY = 15.0
+
 
 class GoogleScholarClient:
     """Client for fetching citation counts from Google Scholar.
@@ -17,7 +19,7 @@ class GoogleScholarClient:
 
     def __init__(
         self,
-        rate_limit_delay: float = 2.0,
+        rate_limit_delay: float = DEFAULT_RATE_LIMIT_DELAY,
         proxy: Optional[str] = None,
         use_free_proxy: bool = False,
     ):
@@ -25,7 +27,8 @@ class GoogleScholarClient:
 
         Args:
             rate_limit_delay: Delay between requests in seconds.
-                              Default is 2 seconds to avoid rate limiting.
+                              Default is intentionally conservative because
+                              Google Scholar is scraped, not an official API.
             proxy: HTTP/HTTPS proxy URL (e.g., "http://user:pass@host:port")
             use_free_proxy: Use free rotating proxies via free-proxy library
         """
@@ -186,7 +189,7 @@ class GoogleScholarClient:
 
         return similarity >= threshold
 
-    def get_citations(self, title: str, limit: int = 50) -> List[dict]:
+    def get_citations(self, title: str, limit: int = 20) -> List[dict]:
         """Get papers that cite a given paper (forward citations).
 
         Args: