scrapebadger-cli 0.24.2__tar.gz → 0.26.0__tar.gz

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scrapebadger-cli
-Version: 0.24.2
+Version: 0.26.0
 Summary: ScrapeBadger CLI — Twitter, Vinted, Google, and Web Scraping from the command line
 Author: ScrapeBadger Team
 License: MIT

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scrapebadger-cli"
-version = "0.24.2"
+version = "0.26.0"
 description = "ScrapeBadger CLI — Twitter, Vinted, Google, and Web Scraping from the command line"
 requires-python = ">=3.10"
 license = {text = "MIT"}

scrapebadger_cli-0.26.0/src/scrapebadger_cli/commands/copilot.py

@@ -0,0 +1,87 @@
+"""Microsoft Copilot answer-engine 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")
+COUNTRY = typer.Option(
+    None,
+    "--country",
+    "-c",
+    help="ISO-3166 alpha-2 country to ask from; also sets the market unless --market. "
+    "Best-effort: another country may answer (the response `country` says which) unless "
+    "--strict-country is set",
+)
+MARKET = typer.Option(
+    None, "--market", "-m", help="Bing market, e.g. ja-JP or en-GB (default: the country's)"
+)
+STRICT = typer.Option(
+    False,
+    "--strict-country",
+    help="Answer only from an exit in --country; fails with 503 country_unavailable "
+    "(not billed) when none answers in time",
+)
+
+
+def _locale(country: str | None, market: str | None, strict_country: bool) -> dict:
+    params: dict = {"country": country, "market": market}
+    return {**params, "strict_country": True} if strict_country else params
+
+
+@app.command()
+def ask(
+    prompt: str = typer.Argument(..., help="Prompt to send to Copilot (max 2000 chars)"),
+    country: str | None = COUNTRY,
+    market: str | None = MARKET,
+    strict_country: bool = STRICT,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Ask Microsoft Copilot (Copilot Search in Bing) and get the answer with its sources."""
+    data = api_get(
+        "/v1/copilot/ask", {"prompt": prompt, **_locale(country, market, strict_country)}
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="brand")
+def brand_visibility(
+    prompt: str = typer.Argument(..., help="Buyer-intent prompt, e.g. 'best CRM for startups'"),
+    brand: str = typer.Option(..., "--brand", "-b", help="Brand name to look for"),
+    domain: str | None = typer.Option(None, "--domain", "-d", help="Brand domain, for citations"),
+    aliases: str | None = typer.Option(
+        None, "--aliases", help="Comma-separated alternative brand spellings"
+    ),
+    competitors: str | None = typer.Option(
+        None, "--competitors", help="Comma-separated competitor names"
+    ),
+    country: str | None = COUNTRY,
+    market: str | None = MARKET,
+    strict_country: bool = STRICT,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Score how a brand appears in a real Copilot answer (AEO/GEO)."""
+    data = api_get(
+        "/v1/copilot/brand-visibility",
+        {
+            "prompt": prompt,
+            "brand": brand,
+            "domain": domain,
+            "aliases": aliases,
+            "competitors": competitors,
+            **_locale(country, market, strict_country),
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def markets(fmt: str = FMT, fields: str | None = FIELDS) -> None:
+    """List the Bing markets Copilot can be asked in."""
+    render(api_get("/v1/copilot/markets"), fmt, fields)

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/src/scrapebadger_cli/commands/facebook.py

@@ -112,6 +112,37 @@ def locations(
     render(data, fmt, fields)
 
 
+@app.command(name="resolve-location")
+def resolve_location(
+    query: str | None = typer.Argument(
+        None, help="Town, city, postcode or address (e.g. 'Durham', 'DH1 3LE')"
+    ),
+    latitude: float | None = typer.Option(None, "--lat", help="Resolve this point instead"),
+    longitude: float | None = typer.Option(None, "--lng"),
+    country: str | None = typer.Option(
+        None, "--country", help="ISO country hint for an ambiguous name (e.g. gb)"
+    ),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Resolve a town/postcode/coordinates to a Marketplace location id (free).
+
+    Pass the returned place_id as --location on marketplace-search/category.
+    """
+    params = {
+        k: v
+        for k, v in {
+            "query": query,
+            "latitude": latitude,
+            "longitude": longitude,
+            "country": country,
+        }.items()
+        if v is not None
+    }
+    data = api_get("/v1/facebook/marketplace/locations/resolve", params)
+    render(data, fmt, fields)
+
+
 @app.command()
 def categories(
     fmt: str = FMT,

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/src/scrapebadger_cli/commands/perplexity.py

@@ -10,20 +10,38 @@ 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")
 COUNTRY = typer.Option("US", "--country", "-c", help="ISO-3166 alpha-2 egress country")
+ASK_COUNTRY = typer.Option(
+    "US",
+    "--country",
+    "-c",
+    help="ISO-3166 alpha-2 market. Best-effort: another market may answer "
+    "(the response `country` says which) unless --strict-country is set",
+)
+STRICT = typer.Option(
+    False,
+    "--strict-country",
+    help="Answer only from an exit in --country; fails with 503 country_unavailable "
+    "(not billed) when none answers in time",
+)
+
+
+def _strict(params: dict, strict_country: bool) -> dict:
+    return {**params, "strict_country": True} if strict_country else params
 
 
 @app.command()
 def ask(
     prompt: str = typer.Argument(..., help="Prompt to send to perplexity.ai (max 4096 chars)"),
-    country: str = COUNTRY,
+    country: str = ASK_COUNTRY,
     focus: str = typer.Option("web", "--focus", help="Retrieval focus: web, scholar or social"),
+    strict_country: bool = STRICT,
     fmt: str = FMT,
     fields: str | None = FIELDS,
 ) -> None:
     """Ask the real perplexity.ai and get the grounded answer with its cited sources."""
     data = api_get(
         "/v1/perplexity/ask",
-        {"prompt": prompt, "country": country, "focus": focus},
+        _strict({"prompt": prompt, "country": country, "focus": focus}, strict_country),
     )
     render(data, fmt, fields)
 
@@ -39,21 +57,25 @@ def brand_visibility(
     competitors: str | None = typer.Option(
         None, "--competitors", help="Comma-separated competitor names"
     ),
-    country: str = COUNTRY,
+    country: str = ASK_COUNTRY,
+    strict_country: bool = STRICT,
     fmt: str = FMT,
     fields: str | None = FIELDS,
 ) -> None:
     """Score how a brand appears in a real Perplexity answer (AEO/GEO)."""
     data = api_get(
         "/v1/perplexity/brand-visibility",
-        {
-            "prompt": prompt,
-            "brand": brand,
-            "domain": domain,
-            "aliases": aliases,
-            "competitors": competitors,
-            "country": country,
-        },
+        _strict(
+            {
+                "prompt": prompt,
+                "brand": brand,
+                "domain": domain,
+                "aliases": aliases,
+                "competitors": competitors,
+                "country": country,
+            },
+            strict_country,
+        ),
     )
     render(data, fmt, fields)
 

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/src/scrapebadger_cli/main.py

@@ -17,6 +17,7 @@ from scrapebadger_cli.commands import (
     bing,
     booking,
     chatgpt,
+    copilot,
     depop,
     duckduckgo,
     ebay,
@@ -115,6 +116,7 @@ app.add_typer(apartments.app, name="apartments", help="Apartments.com rental com
 app.add_typer(linkedin.app, name="linkedin", help="LinkedIn public data commands")
 app.add_typer(chatgpt.app, name="chatgpt", help="ChatGPT LLM scraping commands")
 app.add_typer(perplexity.app, name="perplexity", help="Perplexity AI answer-engine commands")
+app.add_typer(copilot.app, name="copilot", help="Microsoft Copilot answer-engine commands")
 app.add_typer(gemini.app, name="gemini", help="Google Gemini LLM commands")
 app.add_typer(
     facebook.app,

scrapebadger_cli-0.26.0/tests/test_copilot_commands.py

@@ -0,0 +1,42 @@
+from unittest.mock import Mock
+
+import pytest
+
+CliRunner = pytest.importorskip("typer.testing").CliRunner
+copilot = pytest.importorskip(
+    "scrapebadger_cli.commands.copilot", reason="CLI is tested with its own installed package"
+)
+
+
+def _invoke(monkeypatch, args):
+    call = Mock(return_value={})
+    monkeypatch.setattr(copilot, "api_get", call)
+    monkeypatch.setattr(copilot, "render", Mock())
+    result = CliRunner().invoke(copilot.app, args)
+    assert result.exit_code == 0, result.output
+    return call.call_args.args
+
+
+def test_ask_leaves_locale_to_the_api_by_default(monkeypatch):
+    path, params = _invoke(monkeypatch, ["ask", "q"])
+    assert path == "/v1/copilot/ask"
+    assert params["country"] is None and params["market"] is None
+    assert "strict_country" not in params
+
+
+def test_ask_country_market_and_strict(monkeypatch):
+    _, params = _invoke(
+        monkeypatch, ["ask", "q", "-c", "JP", "--market", "ja-JP", "--strict-country"]
+    )
+    assert params == {"prompt": "q", "country": "JP", "market": "ja-JP", "strict_country": True}
+
+
+def test_brand(monkeypatch):
+    path, params = _invoke(monkeypatch, ["brand", "q", "--brand", "freee", "-c", "JP"])
+    assert path == "/v1/copilot/brand-visibility"
+    assert params["brand"] == "freee" and params["country"] == "JP"
+
+
+def test_markets(monkeypatch):
+    path, *_ = _invoke(monkeypatch, ["markets"])
+    assert path == "/v1/copilot/markets"

scrapebadger_cli-0.26.0/tests/test_perplexity_strict_country.py

@@ -0,0 +1,36 @@
+from unittest.mock import Mock
+
+import pytest
+
+CliRunner = pytest.importorskip("typer.testing").CliRunner
+perplexity = pytest.importorskip(
+    "scrapebadger_cli.commands.perplexity", reason="CLI is tested with its own installed package"
+)
+
+
+def _invoke(monkeypatch, args):
+    call = Mock(return_value={})
+    monkeypatch.setattr(perplexity, "api_get", call)
+    monkeypatch.setattr(perplexity, "render", Mock())
+    result = CliRunner().invoke(perplexity.app, args)
+    assert result.exit_code == 0, result.output
+    return call.call_args.args
+
+
+def test_ask_omits_strict_country_by_default(monkeypatch):
+    path, params = _invoke(monkeypatch, ["ask", "q", "--country", "DE"])
+    assert path == "/v1/perplexity/ask"
+    assert params["country"] == "DE" and "strict_country" not in params
+
+
+def test_ask_strict_country(monkeypatch):
+    _, params = _invoke(monkeypatch, ["ask", "q", "--country", "DE", "--strict-country"])
+    assert params["strict_country"] is True
+
+
+def test_brand_strict_country(monkeypatch):
+    path, params = _invoke(
+        monkeypatch, ["brand", "q", "--brand", "Nike", "-c", "JP", "--strict-country"]
+    )
+    assert path == "/v1/perplexity/brand-visibility"
+    assert params["strict_country"] is True and params["country"] == "JP"

{scrapebadger_cli-0.24.2 → scrapebadger_cli-0.26.0}/uv.lock

@@ -228,7 +228,7 @@ wheels = [
 
 [[package]]
 name = "scrapebadger-cli"
-version = "0.24.2"
+version = "0.26.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },