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

scholarinboxcli/commands/collections.py

@@ -0,0 +1,130 @@
+"""Collection command group."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from scholarinboxcli.commands.common import print_output, with_client
+from scholarinboxcli.services.collections import resolve_collection_id
+
+
+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")
+
+    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}")
+
+    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"),
+    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)
+        print_output(data, json_output, title="Similar Papers")
+
+    with_client(no_retry, action)

scholarinboxcli/commands/common.py

@@ -0,0 +1,53 @@
+"""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) -> None:
+    if use_json or not sys.stdout.isatty():
+        typer.echo(format_json(data))
+        return
+
+    table = format_table(data, title=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,34 @@
+"""Conference command group."""
+
+from __future__ import annotations
+
+import typer
+
+from scholarinboxcli.commands.common import print_output, with_client
+
+
+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")
+
+    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")
+
+    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/services/__init__.py

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

scholarinboxcli/services/collections.py

@@ -0,0 +1,132 @@
+"""Collection name/ID resolution helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from scholarinboxcli.api.client import ApiError, ScholarInboxClient
+
+
+def normalize_name(name: str) -> str:
+    return name.strip().lower()
+
+
+def collection_candidates(items: object) -> list[tuple[str, str]]:
+    if not isinstance(items, list):
+        return []
+    candidates: list[tuple[str, str]] = []
+    for item in items:
+        if isinstance(item, dict):
+            name = item.get("name") or item.get("collection_name") or ""
+            cid = str(item.get("id") or item.get("collection_id") or "")
+        elif isinstance(item, str):
+            name = item
+            cid = ""
+        else:
+            continue
+        if name:
+            candidates.append((name, cid))
+    return candidates
+
+
+def collection_items_from_response(data: object) -> object:
+    if isinstance(data, dict):
+        for key in ("collections", "expanded_collections", "collection_names"):
+            if key in data:
+                return data.get(key)
+        return data
+    return data
+
+
+def collection_candidates_from_map(data: object) -> list[tuple[str, str]]:
+    if not isinstance(data, dict):
+        return []
+    mapping = data.get("collection_names_to_ids_dict")
+    if not isinstance(mapping, dict):
+        return []
+    return [(str(name), str(cid)) for name, cid in mapping.items() if name and cid is not None]
+
+
+def candidates_have_ids(candidates: list[tuple[str, str]]) -> bool:
+    return any(cid for _, cid in candidates)
+
+
+def match_collection_name(candidates: list[tuple[str, str]], identifier: str) -> str | None:
+    target = normalize_name(identifier)
+    names = [(name, cid) for name, cid in candidates if name]
+
+    for name, _ in names:
+        if normalize_name(name) == target:
+            return name
+
+    prefix = [c for c in names if normalize_name(c[0]).startswith(target)]
+    if len(prefix) == 1:
+        return prefix[0][0]
+    if len(prefix) > 1:
+        names_str = ", ".join([n for n, _ in prefix[:10]])
+        raise ApiError(f"Ambiguous collection name. Matches: {names_str}")
+
+    contains = [c for c in names if target in normalize_name(c[0])]
+    if len(contains) == 1:
+        return contains[0][0]
+    if len(contains) > 1:
+        names_str = ", ".join([n for n, _ in contains[:10]])
+        raise ApiError(f"Ambiguous collection name. Matches: {names_str}")
+
+    return None
+
+
+def resolve_collection_id(client: ScholarInboxClient, identifier: str) -> str:
+    """Resolve numeric IDs directly, otherwise match by collection name."""
+    if identifier.isdigit():
+        return identifier
+
+    data = client.collections_list()
+    items = collection_items_from_response(data)
+    candidates = collection_candidates(items)
+
+    if not candidates_have_ids(candidates):
+        try:
+            data = client.collections_expanded()
+            items = collection_items_from_response(data)
+            candidates = collection_candidates(items)
+        except ApiError:
+            pass
+
+    if not candidates_have_ids(candidates):
+        try:
+            data = client.collections_map()
+            mapped = collection_candidates_from_map(data)
+            if mapped:
+                candidates = mapped
+        except ApiError:
+            pass
+
+    if not candidates_have_ids(candidates):
+        matched = match_collection_name(candidates, identifier)
+        if matched:
+            return matched
+        raise ApiError("Unable to resolve collection name (no IDs available)")
+
+    candidates = [(name, cid) for name, cid in candidates if cid]
+    target = normalize_name(identifier)
+
+    for name, cid in candidates:
+        if normalize_name(name) == target:
+            return cid
+
+    prefix = [c for c in candidates if normalize_name(c[0]).startswith(target)]
+    if len(prefix) == 1:
+        return prefix[0][1]
+    if len(prefix) > 1:
+        names = ", ".join([f"{n}({cid})" for n, cid in prefix[:10]])
+        raise ApiError(f"Ambiguous collection name. Matches: {names}")
+
+    contains = [c for c in candidates if target in normalize_name(c[0])]
+    if len(contains) == 1:
+        return contains[0][1]
+    if len(contains) > 1:
+        names = ", ".join([f"{n}({cid})" for n, cid in contains[:10]])
+        raise ApiError(f"Ambiguous collection name. Matches: {names}")
+
+    raise ApiError("Collection name not found")

{scholarinboxcli-0.1.0.dist-info → scholarinboxcli-0.1.1.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: scholarinboxcli
-Version: 0.1.0
+Version: 0.1.1
 Summary: CLI for Scholar Inbox (authenticated web API)
 License-Expression: MIT
+License-File: LICENSE
 Keywords: bibliography,cli,research,scholar
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
@@ -234,3 +235,9 @@ If using an API token:
 export TWINE_USERNAME=__token__
 export TWINE_PASSWORD=<your-pypi-token>
 ```
+
+Automated publish is also configured via GitHub Actions:
+
+- Workflow: `.github/workflows/publish.yml`
+- Trigger: push a tag matching `v*` (for example `v0.1.1`)
+- Auth: PyPI Trusted Publishing (OIDC)

scholarinboxcli-0.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+scholarinboxcli/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+scholarinboxcli/cli.py,sha256=MEpkfuWXC4U_GjT85ue-LRTE_FejFvYhxwtnYbWr18k,1001
+scholarinboxcli/config.py,sha256=cxp1RzNwzT6Iu225EPvs8NhH2YTTMg9fQBjaYIRVDoc,1545
+scholarinboxcli/api/client.py,sha256=8Wd7CzAuku2gP2lrdvv2s81JV5Gr6pqGSggnKdk-7-8,13033
+scholarinboxcli/api/endpoints.py,sha256=aw686_VtgbJelcGbw__cG8qtHVm_f9pGeNEqeuWeOuo,1503
+scholarinboxcli/commands/__init__.py,sha256=aOPGu7M21finmICNxDSxNBpe1C3Vw2Iimh1UBESfekU,42
+scholarinboxcli/commands/auth.py,sha256=D2CXLVMwJTxU3_OLNDZ9YGG-mYzrZ4agTKRLeIS3wx4,916
+scholarinboxcli/commands/bookmarks.py,sha256=S0ah6woZrS3p_T4r-gAZZrTSr8GL2EQb6cEtaCKXD0o,1478
+scholarinboxcli/commands/collections.py,sha256=rfSh98wT-yrDvYjl_1UcbVvEiw-h5yaHCv9WTkNHMWg,5139
+scholarinboxcli/commands/common.py,sha256=KgudFViqscHOCfLe_KPADGr_E_d1KKBoW1ZGje3gHuU,1531
+scholarinboxcli/commands/conferences.py,sha256=wVs-YpdkLVxlwqu3_rYHrJl4j1tIb8exvsp7t96qHqo,997
+scholarinboxcli/commands/papers.py,sha256=mdb3-_iecy_pjavPL_K0cXfVnDsQMU93SbD8T3hJY10,3968
+scholarinboxcli/formatters/json_fmt.py,sha256=Ntcp4EqHugCXg79RIF62c7QHa-lexptLDDTT3IEP65U,197
+scholarinboxcli/formatters/table.py,sha256=GnzpmSJ7M_yq-R-c8no8SE9vXbycvWWPUu6hV4tcJAA,2133
+scholarinboxcli/services/__init__.py,sha256=i-8EAvmxCDyYEjmfILYRcUHUh7ryY5hFS4PZARScFXo,56
+scholarinboxcli/services/collections.py,sha256=mQ67tEmNwspOeWg9NyIIovpqkLMP2ANi4Jso9SHXi5A,4377
+scholarinboxcli-0.1.1.dist-info/METADATA,sha256=E1IrW2o5X9P_-6AJDzcS8K6YvyrGrADdHBgVmAVlcPU,6285
+scholarinboxcli-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+scholarinboxcli-0.1.1.dist-info/entry_points.txt,sha256=iescoEMF_CPwSNSmvlzNDl5pT2VpBL9_1bIq_FFIAKc,60
+scholarinboxcli-0.1.1.dist-info/licenses/LICENSE,sha256=sP1DPhQGvTFx1mH4JhNuczMMbApQgFvhBcVjZKM79gU,1068
+scholarinboxcli-0.1.1.dist-info/RECORD,,

scholarinboxcli-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marek Suppa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

scholarinboxcli-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-scholarinboxcli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-scholarinboxcli/cli.py,sha256=bugBfT66k5EuVPashcG6Pz0IRM0KtRz_c6lNOalm4pk,19242
-scholarinboxcli/config.py,sha256=cxp1RzNwzT6Iu225EPvs8NhH2YTTMg9fQBjaYIRVDoc,1545
-scholarinboxcli/api/client.py,sha256=TE8pIRXh7pHhQGto9CvRpPPT61SJp9SzNhRnQ-2U4M4,13723
-scholarinboxcli/formatters/json_fmt.py,sha256=Ntcp4EqHugCXg79RIF62c7QHa-lexptLDDTT3IEP65U,197
-scholarinboxcli/formatters/table.py,sha256=GnzpmSJ7M_yq-R-c8no8SE9vXbycvWWPUu6hV4tcJAA,2133
-scholarinboxcli-0.1.0.dist-info/METADATA,sha256=JZISdlP49Ezyh-UoLv2FlJIrliHUvZrnj0IvFNWKCMw,6062
-scholarinboxcli-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-scholarinboxcli-0.1.0.dist-info/entry_points.txt,sha256=iescoEMF_CPwSNSmvlzNDl5pT2VpBL9_1bIq_FFIAKc,60
-scholarinboxcli-0.1.0.dist-info/RECORD,,