rdt-cli 0.2.0__py3-none-any.whl

rdt_cli/commands/search.py

@@ -0,0 +1,227 @@
+"""Search and export commands."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import sys
+
+import click
+from rich.table import Table
+
+from ..client import RedditClient
+from ..constants import SEARCH_SORT_OPTIONS, TIME_FILTERS
+from ..exceptions import RedditApiError
+from ..index_cache import save_index
+from ._common import (
+    compact_posts,
+    console,
+    exit_for_error,
+    format_score,
+    listing_options,
+    maybe_print_structured,
+    optional_auth,
+    save_output_to_file,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _render_search_table(
+    posts: list[dict], query: str, full_text: bool = False,
+) -> None:
+    """Render search results as a Rich table."""
+    if not posts:
+        console.print(f"[yellow]No results for '{query}'[/yellow]")
+        return
+
+    save_index(posts, source=f"search:{query}")
+    max_title = 200 if full_text else 45
+
+    table = Table(title=f'🔍 Search: "{query}" — {len(posts)} results', show_lines=True)
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Score", style="yellow", width=6, justify="right")
+    table.add_column("Subreddit", style="magenta", max_width=15)
+    table.add_column(
+        "Title", style="bold cyan",
+        max_width=max_title if not full_text else None,
+    )
+    table.add_column("Author", style="green", max_width=12)
+    table.add_column("💬", style="dim", width=5, justify="right")
+
+    for i, post in enumerate(posts, 1):
+        title_text = post.get("title", "-")
+        if not full_text:
+            title_text = title_text[:max_title]
+        table.add_row(
+            str(i),
+            format_score(post.get("score", 0)),
+            f"r/{post.get('subreddit', '?')}",
+            title_text,
+            post.get("author", "-")[:12],
+            str(post.get("num_comments", 0)),
+        )
+
+    console.print(table)
+    console.print("\n  [dim]💡 Use [bold]rdt show <#>[/bold] to read a result[/dim]")
+
+
+# ── search ──────────────────────────────────────────────────────────
+
+
+@click.command()
+@click.argument("query")
+@click.option("-r", "--subreddit", default=None, help="Search within subreddit")
+@click.option(
+    "-s", "--sort", type=click.Choice(SEARCH_SORT_OPTIONS),
+    default="relevance", help="Sort order",
+)
+@click.option(
+    "-t", "--time", "time_filter",
+    type=click.Choice(TIME_FILTERS), default="all", help="Time filter",
+)
+@click.option("-n", "--limit", default=25, type=int, help="Number of results")
+@click.option("--after", default=None, help="Pagination cursor")
+@listing_options
+def search(
+    query: str,
+    subreddit: str | None,
+    sort: str,
+    time_filter: str,
+    limit: int,
+    after: str | None,
+    as_json: bool,
+    as_yaml: bool,
+    output_file: str | None,
+    full_text: bool,
+    compact: bool,
+) -> None:
+    """Search Reddit posts
+
+    Examples:
+      rdt search "python async"
+      rdt search "rust vs go" -r programming --sort top --time year
+    """
+    cred = optional_auth()
+
+    try:
+        with RedditClient(cred) as client:
+            data = client.search(
+                query=query,
+                subreddit=subreddit,
+                sort=sort,
+                time_filter=time_filter,
+                limit=limit,
+                after=after,
+            )
+
+        posts = RedditClient._extract_posts(data)
+        if posts:
+            save_index(posts, source=f"search:{query}")
+
+        # --output: save to file
+        if output_file:
+            out_data = compact_posts(posts) if compact else data
+            save_output_to_file(out_data, output_file)
+            return
+
+        # --compact: strip fields for structured output
+        out_data = data
+        if compact and (as_json or as_yaml):
+            out_data = compact_posts(posts)
+
+        if maybe_print_structured(out_data, as_json=as_json, as_yaml=as_yaml):
+            # Show pagination hint
+            cursor = RedditClient._extract_after(data)
+            if cursor:
+                console.print(
+                    f'  [dim]▸ More: rdt search "{query}" --after {cursor}[/dim]',
+                )
+            return
+
+        _render_search_table(posts, query, full_text=full_text)
+
+        # Show pagination hint
+        cursor = RedditClient._extract_after(data)
+        if cursor and sys.stdout.isatty():
+            console.print(f'  [dim]▸ More: rdt search "{query}" --after {cursor}[/dim]')
+
+    except RedditApiError as exc:
+        exit_for_error(exc, as_json=as_json, as_yaml=as_yaml, prefix="Search failed")
+
+
+# ── export ──────────────────────────────────────────────────────────
+
+
+@click.command()
+@click.argument("query")
+@click.option("-r", "--subreddit", default=None, help="Search within subreddit")
+@click.option("-s", "--sort", type=click.Choice(SEARCH_SORT_OPTIONS), default="relevance", help="Sort order")
+@click.option("-n", "--count", default=50, type=int, help="Number of results to export")
+@click.option("-o", "--output", "output_file", default=None, help="Output file path")
+@click.option("--format", "fmt", type=click.Choice(["csv", "json"]), default="csv", help="Output format")
+def export(query: str, subreddit: str | None, sort: str, count: int, output_file: str | None, fmt: str) -> None:
+    """Export search results to CSV or JSON
+
+    Examples:
+      rdt export "machine learning" -n 100 -o results.csv
+      rdt export "python tips" --format json -o tips.json
+    """
+    cred = optional_auth()
+    all_posts: list[dict] = []
+    after = None
+
+    try:
+        with RedditClient(cred) as client:
+            pages = 0
+            max_pages = (count + 24) // 25
+
+            while len(all_posts) < count and pages < max_pages:
+                data = client.search(query=query, subreddit=subreddit, sort=sort, limit=25, after=after)
+                posts = RedditClient._extract_posts(data)
+                if not posts:
+                    break
+                all_posts.extend(posts)
+                after = RedditClient._extract_after(data)
+                if not after:
+                    break
+                pages += 1
+
+        all_posts = all_posts[:count]
+
+        if not all_posts:
+            console.print(f"[yellow]No results found for '{query}'[/yellow]")
+            return
+
+        if fmt == "json":
+            text = json.dumps(all_posts, indent=2, ensure_ascii=False)
+        else:
+            buf = io.StringIO()
+            fieldnames = ["title", "subreddit", "author", "score", "num_comments", "url", "permalink"]
+            writer = csv.DictWriter(buf, fieldnames=fieldnames, extrasaction="ignore")
+            writer.writeheader()
+            for p in all_posts:
+                row = {
+                    "title": p.get("title", ""),
+                    "subreddit": p.get("subreddit", ""),
+                    "author": p.get("author", ""),
+                    "score": p.get("score", 0),
+                    "num_comments": p.get("num_comments", 0),
+                    "url": p.get("url", ""),
+                    "permalink": f"https://reddit.com{p.get('permalink', '')}",
+                }
+                writer.writerow(row)
+            text = buf.getvalue()
+
+        if output_file:
+            encoding = "utf-8-sig" if fmt == "csv" else "utf-8"
+            with open(output_file, "w", encoding=encoding) as f:
+                f.write(text)
+            console.print(f"[green]✅ Exported {len(all_posts)} results to {output_file}[/green]")
+        else:
+            click.echo(text)
+
+    except RedditApiError as exc:
+        exit_for_error(exc, prefix="Export failed")

rdt_cli/commands/social.py

@@ -0,0 +1,163 @@
+"""Social / interaction commands: upvote, save, subscribe, comment."""
+
+from __future__ import annotations
+
+import click
+
+from ..client import RedditClient
+from ..exceptions import RedditApiError
+from ..index_cache import get_item_by_index
+from ._common import console, exit_for_error, require_auth, write_delay
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _resolve_fullname(id_or_index: str) -> str | None:
+    """Resolve an ID or short-index to a Reddit fullname (t3_xxx).
+
+    Accepts:
+    - Short index (e.g., "3") → from cache
+    - Bare post ID (e.g., "1abc123") → prepend t3_
+    - Full name (e.g., "t3_1abc123") → as-is
+    """
+    # Try as short-index first
+    try:
+        idx = int(id_or_index)
+        item = get_item_by_index(idx)
+        if item:
+            name = item.get("name", "")
+            if name:
+                return name
+            pid = item.get("id", "")
+            if pid:
+                return f"t3_{pid}"
+        console.print(f"[yellow]Index {idx} not found in cache[/yellow]")
+        return None
+    except ValueError:
+        pass
+
+    # Full name
+    if id_or_index.startswith("t3_") or id_or_index.startswith("t1_"):
+        return id_or_index
+
+    # Bare ID → assume post
+    return f"t3_{id_or_index}"
+
+
+# ── upvote ──────────────────────────────────────────────────────────
+
+
+@click.command()
+@click.argument("id_or_index")
+@click.option("--undo", is_flag=True, help="Remove vote")
+@click.option("--down", is_flag=True, help="Downvote instead")
+def upvote(id_or_index: str, undo: bool, down: bool) -> None:
+    """Upvote a post (by ID or index number)
+
+    Examples:
+      rdt upvote 3           # upvote result #3
+      rdt upvote 1abc123     # upvote by post ID
+      rdt upvote 3 --down    # downvote
+      rdt upvote 3 --undo    # remove vote
+    """
+    cred = require_auth()
+    fullname = _resolve_fullname(id_or_index)
+    if not fullname:
+        return
+
+    direction = 0 if undo else (-1 if down else 1)
+    action_label = "Unvoted" if undo else ("⬇ Downvoted" if down else "⬆ Upvoted")
+
+    try:
+        with RedditClient(cred) as client:
+            client.vote(fullname, direction=direction)
+        write_delay()
+        console.print(f"[green]✅ {action_label}[/green] {fullname}")
+    except RedditApiError as exc:
+        exit_for_error(exc, prefix="Vote failed")
+
+
+# ── save / unsave ──────────────────────────────────────────────────
+
+
+@click.command()
+@click.argument("id_or_index")
+@click.option("--undo", is_flag=True, help="Unsave")
+def save(id_or_index: str, undo: bool) -> None:
+    """Save a post (by ID or index number)
+
+    Examples:
+      rdt save 3           # save result #3
+      rdt save 3 --undo    # unsave
+    """
+    cred = require_auth()
+    fullname = _resolve_fullname(id_or_index)
+    if not fullname:
+        return
+
+    try:
+        with RedditClient(cred) as client:
+            if undo:
+                client.unsave_item(fullname)
+                write_delay()
+                console.print(f"[green]✅ Unsaved[/green] {fullname}")
+            else:
+                client.save_item(fullname)
+                write_delay()
+                console.print(f"[green]✅ Saved[/green] {fullname}")
+    except RedditApiError as exc:
+        exit_for_error(exc, prefix="Save failed")
+
+
+# ── subscribe / unsubscribe ────────────────────────────────────────
+
+
+@click.command()
+@click.argument("subreddit")
+@click.option("--undo", is_flag=True, help="Unsubscribe")
+def subscribe(subreddit: str, undo: bool) -> None:
+    """Subscribe to a subreddit
+
+    Examples:
+      rdt subscribe python
+      rdt subscribe python --undo
+    """
+    cred = require_auth()
+    action = "unsub" if undo else "sub"
+    label = "Unsubscribed from" if undo else "Subscribed to"
+
+    try:
+        with RedditClient(cred) as client:
+            client.subscribe(subreddit, action=action)
+        write_delay()
+        console.print(f"[green]✅ {label}[/green] r/{subreddit}")
+    except RedditApiError as exc:
+        exit_for_error(exc, prefix="Subscribe failed")
+
+
+# ── comment ─────────────────────────────────────────────────────────
+
+
+@click.command()
+@click.argument("id_or_index")
+@click.argument("text")
+def comment(id_or_index: str, text: str) -> None:
+    """Post a comment on a post (by ID or index number)
+
+    Examples:
+      rdt comment 3 "Great post!"
+      rdt comment 1abc123 "Thanks for sharing"
+    """
+    cred = require_auth()
+    fullname = _resolve_fullname(id_or_index)
+    if not fullname:
+        return
+
+    try:
+        with RedditClient(cred) as client:
+            client.post_comment(fullname, text)
+        write_delay()
+        console.print(f"[green]✅ Comment posted[/green] on {fullname}")
+    except RedditApiError as exc:
+        exit_for_error(exc, prefix="Comment failed")
+

rdt_cli/constants.py

@@ -0,0 +1,83 @@
+"""Constants for Reddit CLI — API endpoints, headers, and config paths."""
+
+from pathlib import Path
+
+# ── Config ──────────────────────────────────────────────────────────
+CONFIG_DIR = Path.home() / ".config" / "rdt-cli"
+CREDENTIAL_FILE = CONFIG_DIR / "credential.json"
+
+# ── Base URL ────────────────────────────────────────────────────────
+BASE_URL = "https://www.reddit.com"
+OAUTH_URL = "https://oauth.reddit.com"
+
+# ── Reddit JSON API ─────────────────────────────────────────────────
+# Reddit's public JSON API: append .json to any URL
+# Authenticated endpoints use oauth.reddit.com
+
+# Listing endpoints (GET, append .json)
+HOME_URL = "/.json"
+POPULAR_URL = "/r/popular.json"
+ALL_URL = "/r/all.json"
+SUBREDDIT_URL = "/r/{subreddit}.json"              # hot by default
+SUBREDDIT_NEW_URL = "/r/{subreddit}/new.json"
+SUBREDDIT_TOP_URL = "/r/{subreddit}/top.json"
+SUBREDDIT_RISING_URL = "/r/{subreddit}/rising.json"
+SUBREDDIT_ABOUT_URL = "/r/{subreddit}/about.json"
+
+# Post / comments
+POST_COMMENTS_URL = "/r/{subreddit}/comments/{post_id}.json"
+POST_COMMENTS_SHORT_URL = "/comments/{post_id}.json"
+
+# Search
+SEARCH_URL = "/search.json"
+SUBREDDIT_SEARCH_URL = "/r/{subreddit}/search.json"
+
+# User
+USER_ABOUT_URL = "/user/{username}/about.json"
+USER_POSTS_URL = "/user/{username}/submitted.json"
+USER_COMMENTS_URL = "/user/{username}/comments.json"
+USER_SAVED_URL = "/user/{username}/saved.json"
+USER_UPVOTED_URL = "/user/{username}/upvoted.json"
+
+# Auth / identity (OAuth)
+ME_URL = "/api/v1/me"
+
+# Write actions (OAuth, POST)
+VOTE_URL = "/api/vote"
+SAVE_URL = "/api/save"
+UNSAVE_URL = "/api/unsave"
+SUBSCRIBE_URL = "/api/subscribe"
+COMMENT_URL = "/api/comment"
+
+# ── Request Headers (Chrome 133, macOS) ─────────────────────────────
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/133.0.0.0 Safari/537.36"
+    ),
+    "sec-ch-ua": '"Chromium";v="133", "Not(A:Brand";v="99", "Google Chrome";v="133"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"macOS"',
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "same-origin",
+    "Accept": "application/json, text/plain, */*",
+    "Accept-Language": "en-US,en;q=0.9",
+}
+
+# ── Cookie keys required for authenticated sessions ─────────────────
+REQUIRED_COOKIES = {"reddit_session"}
+
+# ── Sort options ────────────────────────────────────────────────────
+SORT_OPTIONS = ["hot", "new", "top", "rising", "controversial", "best"]
+
+# ── Time filter for top/controversial ───────────────────────────────
+TIME_FILTERS = ["hour", "day", "week", "month", "year", "all"]
+
+# ── Search sort options ─────────────────────────────────────────────
+SEARCH_SORT_OPTIONS = ["relevance", "hot", "top", "new", "comments"]
+
+# ── Default page size ───────────────────────────────────────────────
+DEFAULT_LIMIT = 25
+MAX_LIMIT = 100

rdt_cli/exceptions.py

@@ -0,0 +1,69 @@
+"""Custom exceptions for Reddit CLI API client."""
+
+from __future__ import annotations
+
+
+class RedditApiError(Exception):
+    """Base exception for Reddit API errors."""
+
+    def __init__(self, message: str, code: int | str | None = None, response: dict | None = None):
+        super().__init__(message)
+        self.code = code
+        self.response = response
+
+
+class SessionExpiredError(RedditApiError):
+    """Raised when session cookies have expired."""
+
+    def __init__(self):
+        super().__init__(
+            "Session expired. Please re-login: rdt logout && rdt login",
+            code=401,
+        )
+
+
+class AuthRequiredError(RedditApiError):
+    """Raised when user is not logged in."""
+
+    def __init__(self):
+        super().__init__("Not logged in. Use 'rdt login' to authenticate")
+
+
+class RateLimitError(RedditApiError):
+    """Raised when Reddit rate-limits the request."""
+
+    def __init__(self, retry_after: float | None = None):
+        msg = "Rate limited by Reddit"
+        if retry_after:
+            msg += f" (retry after {retry_after:.0f}s)"
+        super().__init__(msg, code=429)
+        self.retry_after = retry_after
+
+
+class NotFoundError(RedditApiError):
+    """Raised when a subreddit, user, or post is not found."""
+
+    def __init__(self, resource: str = "Resource"):
+        super().__init__(f"{resource} not found", code=404)
+
+
+class ForbiddenError(RedditApiError):
+    """Raised when access is forbidden (private subreddit, etc.)."""
+
+    def __init__(self, resource: str = "Resource"):
+        super().__init__(f"Access forbidden: {resource}", code=403)
+
+
+def error_code_for_exception(exc: Exception) -> str:
+    """Map domain exceptions to stable error code strings."""
+    if isinstance(exc, (AuthRequiredError, SessionExpiredError)):
+        return "not_authenticated"
+    if isinstance(exc, RateLimitError):
+        return "rate_limited"
+    if isinstance(exc, NotFoundError):
+        return "not_found"
+    if isinstance(exc, ForbiddenError):
+        return "forbidden"
+    if isinstance(exc, RedditApiError):
+        return "api_error"
+    return "unknown_error"

rdt_cli/index_cache.py

@@ -0,0 +1,77 @@
+"""Search result index cache for short-index navigation (rdt show 3)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Any
+
+from .constants import CONFIG_DIR
+
+logger = logging.getLogger(__name__)
+
+INDEX_CACHE_FILE = CONFIG_DIR / "index_cache.json"
+
+
+def save_index(items: list[dict], source: str = "search") -> None:
+    """Save a list of posts/items to the index cache."""
+    if not items:
+        return
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    entries = []
+    for item in items:
+        entry = {
+            "id": item.get("id", ""),
+            "name": item.get("name", ""),  # fullname like t3_abc123
+            "title": item.get("title", ""),
+            "subreddit": item.get("subreddit", ""),
+            "author": item.get("author", ""),
+            "score": item.get("score", 0),
+            "num_comments": item.get("num_comments", 0),
+            "permalink": item.get("permalink", ""),
+            "url": item.get("url", ""),
+        }
+        if entry["id"]:
+            entries.append(entry)
+
+    payload = {
+        "source": source,
+        "saved_at": time.time(),
+        "count": len(entries),
+        "items": entries,
+    }
+    INDEX_CACHE_FILE.write_text(json.dumps(payload, indent=2, ensure_ascii=False))
+    INDEX_CACHE_FILE.chmod(0o600)
+    logger.debug("Saved %d items to index cache (source=%s)", len(entries), source)
+
+
+def get_item_by_index(index: int) -> dict | None:
+    """Get a cached item by 1-based index."""
+    if index <= 0 or not INDEX_CACHE_FILE.exists():
+        return None
+    try:
+        data = json.loads(INDEX_CACHE_FILE.read_text())
+        items = data.get("items", [])
+        if index <= len(items):
+            return items[index - 1]
+        return None
+    except (OSError, json.JSONDecodeError, IndexError):
+        return None
+
+
+def get_index_info() -> dict[str, Any]:
+    """Get metadata about the current index cache."""
+    if not INDEX_CACHE_FILE.exists():
+        return {"exists": False, "count": 0}
+    try:
+        data = json.loads(INDEX_CACHE_FILE.read_text())
+        return {
+            "exists": True,
+            "count": data.get("count", 0),
+            "source": data.get("source", ""),
+            "saved_at": data.get("saved_at", 0),
+        }
+    except (OSError, json.JSONDecodeError):
+        return {"exists": False, "count": 0}