tisit-cli 0.1.0__py3-none-any.whl

tisit_cli/commands/note_commands.py

@@ -0,0 +1,131 @@
+"""Note commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_note_detail, print_note_table,
+    print_queued, print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+note_app = typer.Typer(help="Manage your learning notes")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@note_app.command("list")
+def note_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search term"),
+    category: Optional[str] = typer.Option(None, "--category", "-c"),
+    domain: Optional[str] = typer.Option(None, "--domain", "-d"),
+    sort: str = typer.Option("created_at", "--sort", "-s",
+                             help="Sort by: created_at, term, category"),
+    order: str = typer.Option("desc", "--order", "-o", help="asc or desc"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your notes."""
+    client = _get_client()
+    try:
+        notes, meta = client.list_notes(
+            q=query, category=category, domain=domain,
+            sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": notes, "meta": meta}, indent=2, default=str))
+    else:
+        if not notes:
+            print_error("No notes found.")
+        else:
+            print_note_table(notes, meta)
+
+
+@note_app.command("view")
+def note_view(
+    note_id: int = typer.Argument(..., help="Note ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a note in detail."""
+    client = _get_client()
+    try:
+        note = client.get_note(note_id)
+    except NotFoundError:
+        print_error(f"Note {note_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(note, indent=2, default=str))
+    else:
+        print_note_detail(note)
+
+
+@note_app.command("add")
+def note_add(
+    term: str = typer.Argument(..., help="Term to learn about"),
+    context: str = typer.Argument(..., help="Context for the term"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Create a new note (async — queued for processing)."""
+    client = _get_client()
+    try:
+        data = client.create_note(term, context)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        print_queued(data)
+
+
+@note_app.command("delete")
+def note_delete(
+    note_id: int = typer.Argument(..., help="Note ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a note."""
+    if not yes:
+        confirm = typer.confirm(f"Delete note {note_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_note(note_id)
+    except NotFoundError:
+        print_error(f"Note {note_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Note {note_id} deleted.")

tisit_cli/commands/paper_commands.py

@@ -0,0 +1,134 @@
+"""Paper commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_paper_detail, print_paper_table,
+    print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+paper_app = typer.Typer(help="Manage your research papers")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@paper_app.command("list")
+def paper_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search title or authors"),
+    sort: str = typer.Option("uploaded_at", "--sort", "-s", help="Sort by: uploaded_at, title"),
+    order: str = typer.Option("desc", "--order", "-o", help="asc or desc"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your papers."""
+    client = _get_client()
+    try:
+        papers, meta = client.list_papers(
+            q=query, sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": papers, "meta": meta}, indent=2, default=str))
+    else:
+        if not papers:
+            print_error("No papers found.")
+        else:
+            print_paper_table(papers, meta)
+
+
+@paper_app.command("view")
+def paper_view(
+    paper_id: int = typer.Argument(..., help="Paper ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a paper in detail."""
+    client = _get_client()
+    try:
+        paper = client.get_paper(paper_id)
+    except NotFoundError:
+        print_error(f"Paper {paper_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(paper, indent=2, default=str))
+    else:
+        print_paper_detail(paper)
+
+
+@paper_app.command("add")
+def paper_add(
+    url: str = typer.Argument(..., help="Paper URL (PDF or article page)"),
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="Paper title"),
+    authors: Optional[str] = typer.Option(None, "--authors", "-a", help="Paper authors"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a paper by URL (async — queued for processing)."""
+    client = _get_client()
+    try:
+        data = client.add_paper(url, title=title, authors=authors)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if data.get("is_duplicate"):
+            print_success(f"Paper already exists (ID: {data['paper_id']}). You have access.")
+        else:
+            print_success(
+                f"Paper queued for processing (ID: {data['paper_id']}).\n"
+                f"  Check status with: tisit paper view {data['paper_id']}"
+            )
+
+
+@paper_app.command("delete")
+def paper_delete(
+    paper_id: int = typer.Argument(..., help="Paper ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a paper."""
+    if not yes:
+        confirm = typer.confirm(f"Delete paper {paper_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_paper(paper_id)
+    except NotFoundError:
+        print_error(f"Paper {paper_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Paper {paper_id} deleted.")

tisit_cli/commands/patent_commands.py

@@ -0,0 +1,138 @@
+"""Patent commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_patent_detail, print_patent_table,
+    print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+patent_app = typer.Typer(help="Manage your patents")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@patent_app.command("list")
+def patent_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search title or patent number"),
+    sort: str = typer.Option("fetched_at", "--sort", "-s"),
+    order: str = typer.Option("desc", "--order", "-o"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your patents."""
+    client = _get_client()
+    try:
+        patents, meta = client.list_patents(
+            q=query, sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": patents, "meta": meta}, indent=2, default=str))
+    else:
+        if not patents:
+            print_error("No patents found.")
+        else:
+            print_patent_table(patents, meta)
+
+
+@patent_app.command("view")
+def patent_view(
+    patent_id: int = typer.Argument(..., help="Patent ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a patent in detail."""
+    client = _get_client()
+    try:
+        patent = client.get_patent(patent_id)
+    except NotFoundError:
+        print_error(f"Patent {patent_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(patent, indent=2, default=str))
+    else:
+        print_patent_detail(patent)
+
+
+@patent_app.command("add")
+def patent_add(
+    url_or_number: str = typer.Argument(..., help="Patent URL or patent number"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a patent by URL or number (async — queued for processing)."""
+    # Detect whether input is a URL or patent number
+    is_url = url_or_number.startswith("http")
+
+    client = _get_client()
+    try:
+        if is_url:
+            data = client.add_patent(url=url_or_number)
+        else:
+            data = client.add_patent(patent_number=url_or_number)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if data.get("is_duplicate"):
+            print_success(f"Patent already exists (ID: {data['patent_id']}).")
+        else:
+            print_success(
+                f"Patent queued for processing (ID: {data['patent_id']}).\n"
+                f"  Check status with: tisit patent view {data['patent_id']}"
+            )
+
+
+@patent_app.command("delete")
+def patent_delete(
+    patent_id: int = typer.Argument(..., help="Patent ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a patent."""
+    if not yes:
+        confirm = typer.confirm(f"Delete patent {patent_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_patent(patent_id)
+    except NotFoundError:
+        print_error(f"Patent {patent_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Patent {patent_id} deleted.")

tisit_cli/commands/podcast_commands.py

@@ -0,0 +1,132 @@
+"""Podcast commands: add, list, view, delete."""
+import json
+from typing import Optional
+
+import typer
+
+from ..auth import get_token
+from ..client import TisitClient
+from ..config import Config
+from ..display import (
+    print_error, print_podcast_detail, print_podcast_table,
+    print_success,
+)
+from ..exceptions import AuthenticationError, APIError, NotFoundError
+
+podcast_app = typer.Typer(help="Manage your podcast episodes")
+
+
+def _get_client() -> TisitClient:
+    token = get_token()
+    if not token:
+        print_error("Not logged in. Run: tisit login")
+        raise typer.Exit(code=1)
+    cfg = Config()
+    return TisitClient(cfg.api_url, token)
+
+
+@podcast_app.command("list")
+def podcast_list(
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Search title or podcast name"),
+    sort: str = typer.Option("created_at", "--sort", "-s"),
+    order: str = typer.Option("desc", "--order", "-o"),
+    page: int = typer.Option(1, "--page", "-p"),
+    per_page: int = typer.Option(20, "--per-page"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List your podcast episodes."""
+    client = _get_client()
+    try:
+        podcasts, meta = client.list_podcasts(
+            q=query, sort=sort, order=order, page=page, per_page=per_page,
+        )
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps({"data": podcasts, "meta": meta}, indent=2, default=str))
+    else:
+        if not podcasts:
+            print_error("No podcast episodes found.")
+        else:
+            print_podcast_table(podcasts, meta)
+
+
+@podcast_app.command("view")
+def podcast_view(
+    podcast_id: int = typer.Argument(..., help="Podcast episode ID"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """View a podcast episode in detail."""
+    client = _get_client()
+    try:
+        podcast = client.get_podcast(podcast_id)
+    except NotFoundError:
+        print_error(f"Podcast episode {podcast_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(podcast, indent=2, default=str))
+    else:
+        print_podcast_detail(podcast)
+
+
+@podcast_app.command("add")
+def podcast_add(
+    url: str = typer.Argument(..., help="Podcast episode URL (Spotify, Apple, RSS)"),
+    output_json: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """Add a podcast episode by URL (async — queued for processing)."""
+    client = _get_client()
+    try:
+        data = client.add_podcast(url)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if data.get("is_duplicate"):
+            print_success(f"Podcast episode already exists (ID: {data['podcast_id']}).")
+        else:
+            print_success(
+                f"Podcast episode queued for processing (ID: {data['podcast_id']}).\n"
+                f"  Check status with: tisit podcast view {data['podcast_id']}"
+            )
+
+
+@podcast_app.command("delete")
+def podcast_delete(
+    podcast_id: int = typer.Argument(..., help="Podcast episode ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a podcast episode."""
+    if not yes:
+        confirm = typer.confirm(f"Delete podcast episode {podcast_id}?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    try:
+        client.delete_podcast(podcast_id)
+    except NotFoundError:
+        print_error(f"Podcast episode {podcast_id} not found.")
+        raise typer.Exit(code=1)
+    except (AuthenticationError, APIError) as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1)
+    finally:
+        client.close()
+
+    print_success(f"Podcast episode {podcast_id} deleted.")