scrapebadger-cli 0.2.1__py3-none-any.whl

scrapebadger_cli/commands/realtor.py

@@ -0,0 +1,91 @@
+"""Realtor real-estate commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+MARKET = typer.Option("us", "--market", "-m", help="Market: us (realtor.com) or ca (realtor.ca)")
+
+
+@app.command()
+def search(
+    location: str = typer.Argument(..., help="Location, e.g. 'Austin, TX', ZIP, 'Toronto, ON'"),
+    market: str = MARKET,
+    status: str | None = typer.Option(None, "--status", help="for_sale, for_rent, sold, pending"),
+    price_min: float | None = typer.Option(None, "--price-min"),
+    price_max: float | None = typer.Option(None, "--price-max"),
+    beds_min: int | None = typer.Option(None, "--beds-min"),
+    baths_min: int | None = typer.Option(None, "--baths-min"),
+    sqft_min: int | None = typer.Option(None, "--sqft-min"),
+    sqft_max: int | None = typer.Option(None, "--sqft-max"),
+    property_type: str | None = typer.Option(
+        None, "--property-type", help="CSV: single_family,condos,townhomes,multi_family,mobile,land"
+    ),
+    sort: str | None = typer.Option(
+        None, "--sort", help="relevant, newest, price_low, price_high, photo_count"
+    ),
+    page: int = typer.Option(1, "--page", "-p"),
+    limit: int | None = typer.Option(None, "--limit", help="Results per page (1-200)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search real-estate listings on realtor.com (US) or realtor.ca (CA)."""
+    data = api_get(
+        "/v1/realtor/search",
+        {
+            "location": location,
+            "market": market,
+            "status": status,
+            "price_min": price_min,
+            "price_max": price_max,
+            "beds_min": beds_min,
+            "baths_min": baths_min,
+            "sqft_min": sqft_min,
+            "sqft_max": sqft_max,
+            "property_type": property_type,
+            "sort": sort,
+            "page": page,
+            "limit": limit,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def property(
+    property_id: str = typer.Argument(..., help="Realtor property ID"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get full detail for a single property by ID."""
+    data = api_get(f"/v1/realtor/properties/{property_id}", {"market": market})
+    render(data, fmt, fields)
+
+
+@app.command()
+def autocomplete(
+    query: str = typer.Argument(..., help="Partial location text"),
+    market: str = MARKET,
+    limit: int | None = typer.Option(None, "--limit", help="1-25, default 10"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get location autocomplete suggestions (cities, ZIPs, addresses)."""
+    data = api_get("/v1/realtor/autocomplete", {"query": query, "market": market, "limit": limit})
+    render(data, fmt, fields)
+
+
+@app.command()
+def markets(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List supported Realtor markets (us=realtor.com, ca=realtor.ca)."""
+    data = api_get("/v1/realtor/markets")
+    render(data, fmt, fields)

scrapebadger_cli/commands/reddit.py

@@ -0,0 +1,173 @@
+"""Reddit commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+SORT = typer.Option("hot", "--sort", "-s", help="Sort: hot, new, top, rising, controversial")
+TIME = typer.Option("all", "--time", "-t", help="Time: hour, day, week, month, year, all")
+LIMIT = typer.Option(25, "--limit", "-l", help="Results per page (1-100)")
+AFTER = typer.Option(None, "--after", help="Pagination cursor")
+
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Search query"),
+    subreddit: str | None = typer.Option(None, "--subreddit", "-r", help="Restrict to subreddit"),
+    sort: str = typer.Option("relevance", "--sort", "-s"),
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Reddit posts."""
+    data = api_get(
+        "/v1/reddit/search/posts",
+        {"q": query, "subreddit": subreddit, "sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def post(
+    post_id: str = typer.Argument(..., help="Reddit post ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get post details."""
+    data = api_get(f"/v1/reddit/posts/{post_id}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def comments(
+    post_id: str = typer.Argument(..., help="Reddit post ID"),
+    sort: str = typer.Option("confidence", "--sort", "-s"),
+    limit: int = LIMIT,
+    depth: int | None = typer.Option(None, "--depth", help="Max comment depth (0-10)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get post comments."""
+    data = api_get(
+        f"/v1/reddit/posts/{post_id}/comments",
+        {"sort": sort, "limit": limit, "depth": depth},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def subreddit(
+    name: str = typer.Argument(..., help="Subreddit name"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get subreddit details."""
+    data = api_get(f"/v1/reddit/subreddits/{name}")
+    render(data, fmt, fields)
+
+
+@app.command(name="subreddit-posts")
+def subreddit_posts(
+    name: str = typer.Argument(..., help="Subreddit name"),
+    sort: str = SORT,
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get posts from a subreddit."""
+    data = api_get(
+        f"/v1/reddit/subreddits/{name}/posts",
+        {"sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def user(
+    username: str = typer.Argument(..., help="Reddit username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get user profile."""
+    data = api_get(f"/v1/reddit/users/{username}")
+    render(data, fmt, fields)
+
+
+@app.command(name="user-posts")
+def user_posts(
+    username: str = typer.Argument(..., help="Reddit username"),
+    sort: str = typer.Option("new", "--sort", "-s"),
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get posts by a user."""
+    data = api_get(
+        f"/v1/reddit/users/{username}/posts",
+        {"sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="user-comments")
+def user_comments(
+    username: str = typer.Argument(..., help="Reddit username"),
+    sort: str = typer.Option("new", "--sort", "-s"),
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get comments by a user."""
+    data = api_get(
+        f"/v1/reddit/users/{username}/comments",
+        {"sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def trending(
+    sort: str = SORT,
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get trending posts from Reddit's front page."""
+    data = api_get(
+        "/v1/reddit/posts/trending",
+        {"sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def domain(
+    domain_name: str = typer.Argument(..., help="Domain (e.g. github.com)"),
+    sort: str = SORT,
+    t: str = TIME,
+    limit: int = LIMIT,
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get posts linking to a domain."""
+    data = api_get(
+        f"/v1/reddit/domains/{domain_name}/posts",
+        {"sort": sort, "t": t, "limit": limit, "after": after},
+    )
+    render(data, fmt, fields)

scrapebadger_cli/commands/stream.py

@@ -0,0 +1,270 @@
+"""Real-time Twitter streaming commands.
+
+Connects to ScrapeBadger's WebSocket endpoint and outputs tweets as NDJSON.
+Also provides monitor and filter-rule management subcommands.
+"""
+
+import asyncio
+import json
+import signal
+import sys
+
+import typer
+import websockets
+
+from scrapebadger_cli.client import api_get, api_post
+from scrapebadger_cli.config import get_api_key
+from scrapebadger_cli.output import console, render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+
+
+# ── Live stream ─────────────────────────────────────────────────────────
+
+
+@app.command(name="live")
+def stream_live(
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress connection messages"),
+) -> None:
+    """Connect to the real-time tweet stream (WebSocket).
+
+    Outputs tweets as NDJSON (one JSON object per line) to stdout.
+    Press Ctrl+C to disconnect.
+
+    Requires at least one active stream monitor or filter rule.
+    """
+    api_key = get_api_key()
+    if not api_key:
+        console.print("[red]No API key. Run: scrapebadger auth[/red]", highlight=False)
+        raise typer.Exit(1)
+
+    asyncio.run(_stream_ws(api_key, quiet))
+
+
+async def _stream_ws(api_key: str, quiet: bool) -> None:
+    """Connect to WebSocket and stream tweets to stdout."""
+    import os
+
+    base = os.environ.get("SCRAPEBADGER_API_URL", "https://scrapebadger.com")
+    ws_url = base.replace("https://", "wss://").replace("http://", "ws://")
+    ws_url = f"{ws_url}/v1/twitter/stream?api_key={api_key}"
+
+    stop = asyncio.Event()
+
+    def _signal_handler() -> None:
+        stop.set()
+
+    loop = asyncio.get_event_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _signal_handler)
+        except NotImplementedError:
+            pass
+
+    if not quiet:
+        console.print("[dim]Connecting to tweet stream...[/dim]", highlight=False)
+
+    try:
+        async for ws in websockets.connect(ws_url, ping_interval=30, ping_timeout=10):
+            try:
+                if not quiet:
+                    console.print(
+                        "[green]Connected.[/green] Waiting for tweets... (Ctrl+C to stop)",
+                        highlight=False,
+                    )
+
+                async for raw in ws:
+                    if stop.is_set():
+                        break
+
+                    try:
+                        msg = json.loads(raw)
+                    except json.JSONDecodeError:
+                        continue
+
+                    msg_type = msg.get("type", "")
+
+                    if msg_type == "connected":
+                        if not quiet:
+                            console.print(
+                                f"[dim]Session: {msg.get('connection_id', '?')[:8]}...[/dim]",
+                                highlight=False,
+                            )
+                        continue
+
+                    if msg_type == "error":
+                        console.print(
+                            f"[red]Stream error: {msg.get('message', 'unknown')}[/red]",
+                            highlight=False,
+                        )
+                        raise typer.Exit(1)
+
+                    if msg_type in ("tweet", "filter_rule_tweet"):
+                        # Output as NDJSON line to stdout (pipe-friendly)
+                        sys.stdout.write(json.dumps(msg, ensure_ascii=False) + "\n")
+                        sys.stdout.flush()
+                    elif msg_type == "ping":
+                        await ws.send(json.dumps({"type": "pong"}))
+
+                if stop.is_set():
+                    break
+
+            except websockets.ConnectionClosed:
+                if stop.is_set():
+                    break
+                if not quiet:
+                    console.print(
+                        "[yellow]Connection lost. Reconnecting...[/yellow]", highlight=False
+                    )
+                continue
+
+    except asyncio.CancelledError:
+        pass
+
+    if not quiet:
+        console.print("\n[dim]Disconnected.[/dim]", highlight=False)
+
+
+# ── Monitor management ──────────────────────────────────────────────────
+
+
+@app.command(name="monitors")
+def list_monitors(
+    status: str | None = typer.Option(None, "--status", "-s", help="Filter: active, paused"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List your stream monitors."""
+    data = api_get("/v1/twitter/stream/monitors", {"status": status})
+    render(data, fmt, fields)
+
+
+@app.command(name="monitor-create")
+def create_monitor(
+    name: str = typer.Argument(..., help="Monitor name/tag"),
+    usernames: str = typer.Argument(..., help="Comma-separated Twitter usernames to monitor"),
+    webhook_url: str | None = typer.Option(None, "--webhook", help="Webhook URL for deliveries"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Create a new stream monitor."""
+    body: dict = {
+        "name": name,
+        "usernames": [u.strip().lstrip("@") for u in usernames.split(",")],
+    }
+    if webhook_url:
+        body["webhook_url"] = webhook_url
+    data = api_post("/v1/twitter/stream/monitors", body)
+    render(data, fmt, fields)
+
+
+@app.command(name="monitor-delete")
+def delete_monitor(
+    monitor_id: str = typer.Argument(..., help="Monitor ID to delete"),
+) -> None:
+    """Delete a stream monitor."""
+    from scrapebadger_cli.client import _get_client
+
+    resp = _get_client().delete(f"/v1/twitter/stream/monitors/{monitor_id}")
+    if resp.status_code == 204:
+        console.print("[green]Monitor deleted.[/green]")
+    else:
+        console.print(f"[red]Error ({resp.status_code}): {resp.text}[/red]")
+
+
+@app.command(name="monitor-pause")
+def pause_monitor(
+    monitor_id: str = typer.Argument(..., help="Monitor ID"),
+) -> None:
+    """Pause a stream monitor."""
+    from scrapebadger_cli.client import _get_client
+
+    resp = _get_client().patch(
+        f"/v1/twitter/stream/monitors/{monitor_id}",
+        json={"status": "paused"},
+    )
+    if resp.status_code < 400:
+        console.print("[green]Monitor paused.[/green]")
+    else:
+        console.print(f"[red]Error ({resp.status_code}): {resp.text}[/red]")
+
+
+@app.command(name="monitor-resume")
+def resume_monitor(
+    monitor_id: str = typer.Argument(..., help="Monitor ID"),
+) -> None:
+    """Resume a paused stream monitor."""
+    from scrapebadger_cli.client import _get_client
+
+    resp = _get_client().patch(
+        f"/v1/twitter/stream/monitors/{monitor_id}",
+        json={"status": "active"},
+    )
+    if resp.status_code < 400:
+        console.print("[green]Monitor resumed.[/green]")
+    else:
+        console.print(f"[red]Error ({resp.status_code}): {resp.text}[/red]")
+
+
+# ── Filter rule management ──────────────────────────────────────────────
+
+
+@app.command(name="rules")
+def list_rules(
+    status: str | None = typer.Option(None, "--status", "-s", help="Filter: active, paused"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List your filter rules."""
+    data = api_get("/v1/twitter/filter-rules", {"status": status})
+    render(data, fmt, fields)
+
+
+@app.command(name="rule-create")
+def create_rule(
+    tag: str = typer.Argument(..., help="Unique label for the rule"),
+    query: str = typer.Argument(..., help="Twitter search query"),
+    interval: float = typer.Option(60.0, "--interval", "-i", help="Polling interval in seconds"),
+    webhook_url: str | None = typer.Option(None, "--webhook", help="Webhook URL"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Create a new filter rule for real-time tweet monitoring."""
+    body: dict = {
+        "tag": tag,
+        "query": query,
+        "interval_seconds": interval,
+    }
+    if webhook_url:
+        body["webhook_url"] = webhook_url
+    data = api_post("/v1/twitter/filter-rules", body)
+    render(data, fmt, fields)
+
+
+@app.command(name="rule-delete")
+def delete_rule(
+    rule_id: str = typer.Argument(..., help="Filter rule ID to delete"),
+) -> None:
+    """Delete a filter rule."""
+    from scrapebadger_cli.client import _get_client
+
+    resp = _get_client().delete(f"/v1/twitter/filter-rules/{rule_id}")
+    if resp.status_code == 204:
+        console.print("[green]Filter rule deleted.[/green]")
+    else:
+        console.print(f"[red]Error ({resp.status_code}): {resp.text}[/red]")
+
+
+@app.command(name="delivery-logs")
+def delivery_logs(
+    page: int = typer.Option(1, "--page"),
+    page_size: int = typer.Option(20, "--page-size"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List recent tweet delivery logs."""
+    data = api_get("/v1/twitter/stream/logs", {"page": page, "page_size": page_size})
+    render(data, fmt, fields)