scholarinboxcli 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

scholarinboxcli/commands/collections.py

@@ -0,0 +1,135 @@
+"""Collection command group."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from scholarinboxcli.commands.common import print_output, with_client
+from scholarinboxcli.formatters.domain_tables import format_collection_list, format_collection_papers
+from scholarinboxcli.services.collections import resolve_collection_id
+from scholarinboxcli.services.paper_sort import sort_paper_response
+
+
+app = typer.Typer(help="Collection commands", no_args_is_help=True)
+
+
+@app.command("list")
+def collection_list(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    expanded: bool = typer.Option(False, "--expanded", help="Use expanded collection metadata"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        data = client.collections_expanded() if expanded else client.collections_list()
+        print_output(data, json_output, title="Collections", table_formatter=format_collection_list)
+
+    with_client(no_retry, action)
+
+
+@app.command("create")
+def collection_create(
+    name: str = typer.Argument(..., help="Collection name"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        data = client.collection_create(name)
+        print_output(data, json_output, title="Collection created")
+
+    with_client(no_retry, action)
+
+
+@app.command("rename")
+def collection_rename(
+    collection_id: str = typer.Argument(..., help="Collection ID or name"),
+    new_name: str = typer.Argument(..., help="New collection name"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        cid = resolve_collection_id(client, collection_id)
+        data = client.collection_rename(cid, new_name)
+        print_output(data, json_output, title="Collection renamed")
+
+    with_client(no_retry, action)
+
+
+@app.command("delete")
+def collection_delete(
+    collection_id: str = typer.Argument(..., help="Collection ID or name"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        cid = resolve_collection_id(client, collection_id)
+        data = client.collection_delete(cid)
+        print_output(data, json_output, title="Collection deleted")
+
+    with_client(no_retry, action)
+
+
+@app.command("add")
+def collection_add(
+    collection_id: str = typer.Argument(..., help="Collection ID or name"),
+    paper_id: str = typer.Argument(..., help="Paper ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        cid = resolve_collection_id(client, collection_id)
+        data = client.collection_add_paper(cid, paper_id)
+        print_output(data, json_output, title="Collection add paper")
+
+    with_client(no_retry, action)
+
+
+@app.command("remove")
+def collection_remove(
+    collection_id: str = typer.Argument(..., help="Collection ID or name"),
+    paper_id: str = typer.Argument(..., help="Paper ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        cid = resolve_collection_id(client, collection_id)
+        data = client.collection_remove_paper(cid, paper_id)
+        print_output(data, json_output, title="Collection remove paper")
+
+    with_client(no_retry, action)
+
+
+@app.command("papers")
+def collection_papers(
+    collection_id: str = typer.Argument(..., help="Collection ID or name"),
+    limit: Optional[int] = typer.Option(None, "--limit", "-n", help="Limit results"),
+    offset: Optional[int] = typer.Option(None, "--offset", help="Pagination offset"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        cid = resolve_collection_id(client, collection_id)
+        data = client.collection_papers(cid, limit=limit, offset=offset)
+        print_output(data, json_output, title=f"Collection {cid}", table_formatter=format_collection_papers)
+
+    with_client(no_retry, action)
+
+
+@app.command("similar")
+def collection_similar(
+    collection_ids: list[str] = typer.Argument(..., help="Collection ID(s) or names"),
+    limit: Optional[int] = typer.Option(None, "--limit", "-n", help="Limit results"),
+    offset: Optional[int] = typer.Option(None, "--offset", help="Pagination offset"),
+    sort_by: Optional[str] = typer.Option(None, "--sort", help="Sort papers by: year, title"),
+    asc: bool = typer.Option(False, "--asc", help="Sort ascending (default is descending)"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        resolved = [resolve_collection_id(client, cid) for cid in collection_ids]
+        data = client.collections_similar(resolved, limit=limit, offset=offset)
+        data = sort_paper_response(data, sort_by, asc)
+        print_output(data, json_output, title="Similar Papers")
+
+    with_client(no_retry, action)

scholarinboxcli/commands/common.py

@@ -0,0 +1,59 @@
+"""Shared command helpers for output and error handling."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Callable, TypeVar
+
+import typer
+
+from scholarinboxcli.api.client import ApiError, ScholarInboxClient
+from scholarinboxcli.formatters.json_fmt import format_json
+from scholarinboxcli.formatters.table import format_table
+
+
+def print_output(
+    data: Any,
+    use_json: bool,
+    title: str | None = None,
+    table_formatter: Callable[[Any, str | None], str] | None = None,
+) -> None:
+    if use_json or not sys.stdout.isatty():
+        typer.echo(format_json(data))
+        return
+
+    formatter = table_formatter or format_table
+    table = formatter(data, title)
+    if table == "(no results)":
+        typer.echo(table)
+        return
+    typer.echo(table)
+
+
+def handle_error(err: ApiError) -> None:
+    if not sys.stdout.isatty():
+        typer.echo(format_json({"error": err.message, "status_code": err.status_code, "detail": err.detail}))
+    else:
+        typer.echo(f"Error: {err.message}", err=True)
+        if err.status_code:
+            typer.echo(f"Status: {err.status_code}", err=True)
+    raise typer.Exit(1)
+
+
+def close_client(client: ScholarInboxClient) -> None:
+    client.close()
+
+
+T = TypeVar("T")
+
+
+def with_client(no_retry: bool, action: Callable[[ScholarInboxClient], T]) -> T:
+    """Run action with a managed client and standardized ApiError handling."""
+    client = ScholarInboxClient(no_retry=no_retry)
+    try:
+        return action(client)
+    except ApiError as err:
+        handle_error(err)
+        raise  # unreachable, keeps type-checkers happy
+    finally:
+        close_client(client)

scholarinboxcli/commands/conferences.py

@@ -0,0 +1,35 @@
+"""Conference command group."""
+
+from __future__ import annotations
+
+import typer
+
+from scholarinboxcli.commands.common import print_output, with_client
+from scholarinboxcli.formatters.domain_tables import format_conference_explore, format_conference_list
+
+
+app = typer.Typer(help="Conference commands", no_args_is_help=True)
+
+
+@app.command("list")
+def conference_list(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        data = client.conference_list()
+        print_output(data, json_output, title="Conferences", table_formatter=format_conference_list)
+
+    with_client(no_retry, action)
+
+
+@app.command("explore")
+def conference_explore(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+):
+    def action(client):
+        data = client.conference_explorer()
+        print_output(data, json_output, title="Conference Explorer", table_formatter=format_conference_explore)
+
+    with_client(no_retry, action)

scholarinboxcli/commands/papers.py

@@ -0,0 +1,88 @@
+"""Top-level feed/search related commands."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from scholarinboxcli.commands.common import print_output, with_client
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("digest")
+    def digest(
+        date: Optional[str] = typer.Option(None, "--date", help="Digest date (MM-DD-YYYY)"),
+        json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+        no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+    ):
+        def action(client):
+            data = client.get_digest(date)
+            print_output(data, json_output, title="Digest")
+
+        with_client(no_retry, action)
+
+    @app.command("trending")
+    def trending(
+        category: str = typer.Option("ALL", "--category", help="Category filter"),
+        days: int = typer.Option(7, "--days", help="Lookback window in days"),
+        sort: str = typer.Option("hype", "--sort", help="Sort column"),
+        asc: bool = typer.Option(False, "--asc", help="Sort ascending"),
+        json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+        no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+    ):
+        def action(client):
+            data = client.get_trending(category=category, days=days, sort=sort, asc=asc)
+            print_output(data, json_output, title="Trending")
+
+        with_client(no_retry, action)
+
+    @app.command("search")
+    def search(
+        query: str = typer.Argument(..., help="Search query"),
+        sort: Optional[str] = typer.Option(None, "--sort", help="Sort option"),
+        limit: Optional[int] = typer.Option(None, "--limit", "-n", help="Limit results"),
+        offset: Optional[int] = typer.Option(None, "--offset", help="Pagination offset"),
+        json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+        no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+    ):
+        def action(client):
+            data = client.search(query=query, sort=sort, limit=limit, offset=offset)
+            print_output(data, json_output, title="Search")
+
+        with_client(no_retry, action)
+
+    @app.command("semantic")
+    def semantic_search(
+        text: Optional[str] = typer.Argument(None, help="Semantic search text"),
+        file: Optional[str] = typer.Option(None, "--file", help="Read query text from file"),
+        limit: Optional[int] = typer.Option(None, "--limit", "-n", help="Limit results"),
+        offset: Optional[int] = typer.Option(None, "--offset", help="Pagination offset"),
+        json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+        no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+    ):
+        if not text and not file:
+            typer.echo("Provide text or --file", err=True)
+            raise typer.Exit(1)
+        if file:
+            text = open(file, "r", encoding="utf-8").read()
+
+        def action(client):
+            data = client.semantic_search(text=text or "", limit=limit, offset=offset)
+            print_output(data, json_output, title="Semantic Search")
+
+        with_client(no_retry, action)
+
+    @app.command("interactions")
+    def interactions(
+        type_: str = typer.Option("all", "--type", help="Interaction type (all/up/down)"),
+        sort: str = typer.Option("ranking_score", "--sort", help="Sort column"),
+        asc: bool = typer.Option(False, "--asc", help="Sort ascending"),
+        json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+        no_retry: bool = typer.Option(False, "--no-retry", help="Disable retry on rate limits"),
+    ):
+        def action(client):
+            data = client.interactions(type_=type_, sort=sort, asc=asc)
+            print_output(data, json_output, title="Interactions")
+
+        with_client(no_retry, action)

scholarinboxcli/formatters/domain_tables.py

@@ -0,0 +1,122 @@
+"""Domain-specific table formatters for non-paper responses."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from scholarinboxcli.formatters.table import format_table
+
+
+def _render(table: Table) -> str:
+    console = Console()
+    with console.capture() as capture:
+        console.print(table)
+    return capture.get()
+
+
+def format_auth_status(data: Any, title: str | None = None) -> str:
+    if not isinstance(data, dict):
+        return format_table(data, title)
+    table = Table(title=title)
+    table.add_column("Field", overflow="fold")
+    table.add_column("Value", overflow="fold")
+    for key, value in data.items():
+        table.add_row(str(key), str(value))
+    return _render(table)
+
+
+def format_collection_list(data: Any, title: str | None = None) -> str:
+    if isinstance(data, list) and data and isinstance(data[0], str):
+        table = Table(title=title)
+        table.add_column("#", justify="right")
+        table.add_column("Name", overflow="fold")
+        for i, name in enumerate(data, start=1):
+            table.add_row(str(i), str(name))
+        return _render(table)
+
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        table = Table(title=title)
+        table.add_column("ID", overflow="fold")
+        table.add_column("Name", overflow="fold")
+        for item in data:
+            cid = item.get("id") or item.get("collection_id") or ""
+            name = item.get("name") or item.get("collection_name") or ""
+            table.add_row(str(cid), str(name))
+        return _render(table)
+
+    if isinstance(data, dict) and "expanded_collections" in data:
+        return format_collection_list(data.get("expanded_collections"), title)
+
+    return format_table(data, title)
+
+
+def format_conference_list(data: Any, title: str | None = None) -> str:
+    rows = data.get("conferences") if isinstance(data, dict) else None
+    if isinstance(rows, list):
+        table = Table(title=title)
+        table.add_column("ID", justify="right")
+        table.add_column("Short")
+        table.add_column("Dates")
+        table.add_column("URL")
+        for row in rows:
+            cid = row.get("conference_id", "")
+            short = row.get("short_title") or row.get("full_title") or ""
+            start = row.get("start_date") or ""
+            end = row.get("end_date") or ""
+            dates = f"{start} -> {end}" if (start or end) else ""
+            url = row.get("conference_url") or ""
+            table.add_row(str(cid), str(short), str(dates), str(url))
+        return _render(table)
+    return format_table(data, title)
+
+
+def format_conference_explore(data: Any, title: str | None = None) -> str:
+    rows = data.get("conf_data_list") if isinstance(data, dict) else None
+    if isinstance(rows, list):
+        table = Table(title=title)
+        table.add_column("Abbrev")
+        table.add_column("Conference")
+        table.add_column("Relevance", justify="right")
+        table.add_column("Years")
+        for row in rows:
+            abbrev = row.get("abbreviation") or ""
+            name = row.get("conference_name") or ""
+            rel = row.get("conf_relevance")
+            rel_str = f"{rel:.3f}" if isinstance(rel, (float, int)) else ""
+            years = row.get("list_of_years") or []
+            years_str = ", ".join(str(y) for y in years[:5])
+            table.add_row(str(abbrev), str(name), rel_str, years_str)
+        return _render(table)
+    return format_table(data, title)
+
+
+def _extract_collection_papers(data: Any) -> list[dict[str, Any]]:
+    if isinstance(data, list):
+        return [item for item in data if isinstance(item, dict)]
+    if isinstance(data, dict):
+        for key in ("papers", "digest_df", "items", "results", "data"):
+            val = data.get(key)
+            if isinstance(val, list):
+                return [item for item in val if isinstance(item, dict)]
+        collections = data.get("collections")
+        if isinstance(collections, list):
+            papers: list[dict[str, Any]] = []
+            for collection in collections:
+                if isinstance(collection, dict):
+                    for key in ("papers", "digest_df"):
+                        val = collection.get(key)
+                        if isinstance(val, list):
+                            papers.extend([item for item in val if isinstance(item, dict)])
+            if papers:
+                return papers
+    return []
+
+
+def format_collection_papers(data: Any, title: str | None = None) -> str:
+    papers = _extract_collection_papers(data)
+    if papers:
+        return format_table(papers, title)
+    return format_table(data, title)

scholarinboxcli/formatters/table.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 from typing import Any
+import json
+from datetime import datetime, timezone
 
 from rich.console import Console
 from rich.table import Table
@@ -17,9 +19,41 @@ def _get_authors(paper: dict[str, Any]) -> str:
                 names.append(a)
             elif isinstance(a, dict):
                 names.append(a.get("name") or a.get("author") or "")
-        return ", ".join([n for n in names if n])
+        return _truncate_text(", ".join([n for n in names if n]), 72)
     if isinstance(authors, str):
-        return authors
+        result = authors
+    else:
+        result = ""
+    return _truncate_text(result, 72)
+
+
+def _truncate_text(text: str, max_len: int) -> str:
+    if len(text) <= max_len:
+        return text
+    if max_len <= 3:
+        return text[:max_len]
+    return text[: max_len - 3] + "..."
+
+
+def _get_year(paper: dict[str, Any]) -> str:
+    year = paper.get("year") or paper.get("publication_year") or paper.get("conference_year")
+    if year is not None:
+        if isinstance(year, float) and year.is_integer():
+            return str(int(year))
+        return str(year)
+
+    publication_date = paper.get("publication_date")
+    if isinstance(publication_date, str) and len(publication_date) >= 4 and publication_date[:4].isdigit():
+        return publication_date[:4]
+    if isinstance(publication_date, (int, float)):
+        try:
+            # Handle epoch milliseconds seen in some API payloads.
+            ts = float(publication_date)
+            if ts > 10_000_000_000:
+                ts /= 1000.0
+            return str(datetime.fromtimestamp(ts, tz=timezone.utc).year)
+        except Exception:
+            return ""
     return ""
 
 
@@ -34,33 +68,67 @@ def _extract_papers(data: Any) -> list[dict[str, Any]]:
     return []
 
 
-def format_table(data: Any, title: str | None = None) -> str:
-    papers = _extract_papers(data)
-    if not papers:
-        return "(no results)"
+def _format_scalar(value: Any) -> str:
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, ensure_ascii=True)
+    return str(value)
+
 
+def _format_kv_table(data: dict[str, Any], title: str | None = None) -> str:
     table = Table(title=title)
-    table.add_column("Title", overflow="fold")
-    table.add_column("Authors", overflow="fold")
-    table.add_column("Year", justify="right")
-    table.add_column("Venue", overflow="fold")
-    table.add_column("ID", overflow="fold")
-
-    for p in papers:
-        title_val = str(p.get("title") or p.get("paper_title") or "")
-        authors_val = _get_authors(p)
-        year_val = str(p.get("year") or p.get("publication_year") or "")
-        venue_val = str(p.get("venue") or p.get("conference") or p.get("journal") or "")
-        pid = str(
-            p.get("paper_id")
-            or p.get("paperId")
-            or p.get("id")
-            or p.get("corpusid")
-            or ""
-        )
-        table.add_row(title_val, authors_val, year_val, venue_val, pid)
+    table.add_column("Field", overflow="fold")
+    table.add_column("Value", overflow="fold")
+    for key, value in data.items():
+        table.add_row(str(key), _format_scalar(value))
+    console = Console()
+    with console.capture() as capture:
+        console.print(table)
+    return capture.get()
+
 
+def _format_list_table(data: list[Any], title: str | None = None) -> str:
+    table = Table(title=title)
+    table.add_column("#", justify="right")
+    table.add_column("Value", overflow="fold")
+    for idx, value in enumerate(data, start=1):
+        table.add_row(str(idx), _format_scalar(value))
     console = Console()
     with console.capture() as capture:
         console.print(table)
     return capture.get()
+
+
+def format_table(data: Any, title: str | None = None) -> str:
+    papers = _extract_papers(data)
+    if papers:
+        table = Table(title=title, show_lines=True, row_styles=["", "dim"])
+        table.add_column("Title", overflow="fold", max_width=68)
+        table.add_column("Authors", overflow="fold", max_width=56)
+        table.add_column("Year", justify="right")
+        table.add_column("Venue", overflow="fold")
+        table.add_column("ID", overflow="fold")
+
+        for p in papers:
+            title_val = str(p.get("title") or p.get("paper_title") or "")
+            authors_val = _get_authors(p)
+            year_val = _get_year(p)
+            venue_val = str(p.get("venue") or p.get("conference") or p.get("journal") or "")
+            pid = str(
+                p.get("paper_id")
+                or p.get("paperId")
+                or p.get("id")
+                or p.get("corpusid")
+                or ""
+            )
+            table.add_row(title_val, authors_val, year_val, venue_val, pid)
+
+        console = Console()
+        with console.capture() as capture:
+            console.print(table)
+        return capture.get()
+
+    if isinstance(data, dict) and data:
+        return _format_kv_table(data, title=title)
+    if isinstance(data, list) and data:
+        return _format_list_table(data, title=title)
+    return "(no results)"

scholarinboxcli/services/__init__.py

@@ -0,0 +1 @@
+"""Service helpers that keep command handlers small."""