geonode-scraper-cli 0.1.0__py3-none-any.whl

geonode_scraper_cli/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

geonode_scraper_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Typer command modules for the gscraper CLI."""

geonode_scraper_cli/commands/_common.py

@@ -0,0 +1,42 @@
+"""Helpers shared across command modules."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import typer
+
+from ..errors import ExitCode
+from ..output import OutputFormat
+
+
+def apply_output_override(ctx: typer.Context, as_json: bool, as_yaml: bool) -> None:
+    """Override the output format set by the global --json/--yaml flags.
+
+    Allows per-command placement: ``gscraper extract https://example.com --json``.
+    """
+    if as_json and as_yaml:
+        raise typer.BadParameter("Use only one of --json or --yaml.")
+    if as_json:
+        ctx.obj.output = OutputFormat.JSON
+    elif as_yaml:
+        ctx.obj.output = OutputFormat.YAML
+
+
+def parse_headers(raw_headers: Iterable[str] | None) -> dict[str, str] | None:
+    """Parse repeated ``--header "Key: Value"`` flags into a dict."""
+    if not raw_headers:
+        return None
+    headers: dict[str, str] = {}
+    for item in raw_headers:
+        if ":" not in item:
+            typer.echo(f"Invalid header '{item}'. Expected 'Key: Value'.", err=True)
+            raise typer.Exit(int(ExitCode.USAGE))
+        key, value = item.split(":", 1)
+        headers[key.strip()] = value.strip()
+    return headers
+
+
+def optional(**kwargs: object) -> dict[str, object]:
+    """Drop keys whose value is ``None`` so schema defaults apply."""
+    return {key: value for key, value in kwargs.items() if value is not None}

geonode_scraper_cli/commands/batch.py

@@ -0,0 +1,114 @@
+"""`gscraper batch` — submit and manage batch extraction jobs."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import (
+    CreateBatchInput,
+    GetBatchStatusInput,
+    ListBatchJobsInput,
+    WaitForBatchInput,
+)
+
+from ..invoke import call, validated
+from ._common import apply_output_override, optional, parse_headers
+
+batch_app = typer.Typer(help="Submit and manage batch extraction jobs.", no_args_is_help=True)
+
+
+@batch_app.command("create")
+def create(
+    ctx: typer.Context,
+    urls: List[str] = typer.Argument(..., help="One or more URLs to extract."),
+    formats: Optional[List[str]] = typer.Option(None, "--format", "-f", help="Output format(s). Repeatable."),
+    render_js: bool = typer.Option(False, "--render-js", help="Render JavaScript with a headless browser."),
+    proxy_country: Optional[str] = typer.Option(None, "--proxy-country", help="ISO 3166-1 alpha-2 country code."),
+    proxy_type: Optional[str] = typer.Option(None, "--proxy-type", help="Proxy type: datacenter, residential, mix."),
+    header: Optional[List[str]] = typer.Option(None, "--header", "-H", help="Request header 'Key: Value'. Repeatable."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Submit multiple URLs in a single batch job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        CreateBatchInput,
+        urls=urls,
+        render_js=render_js,
+        **optional(
+            formats=formats,
+            proxy_country=proxy_country,
+            proxy_type=proxy_type,
+            headers=parse_headers(header),
+        ),
+    )
+    call(ctx, "create_batch", payload)
+
+
+@batch_app.command("status")
+def status(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Batch job ID."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(10, "--page-size", help="Results per page (max 50)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Show the status and per-URL results of a batch job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(GetBatchStatusInput, job_id=job_id, page=page, page_size=page_size)
+    call(ctx, "get_batch_status", payload)
+
+
+@batch_app.command("wait")
+def wait(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Batch job ID."),
+    timeout_seconds: Optional[float] = typer.Option(None, "--timeout", help="Polling timeout override (seconds)."),
+    poll_interval_seconds: Optional[float] = typer.Option(None, "--interval", help="Polling interval override (s)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Poll a batch job until it reaches a terminal state."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        WaitForBatchInput,
+        job_id=job_id,
+        **optional(timeout_seconds=timeout_seconds, poll_interval_seconds=poll_interval_seconds),
+    )
+    call(ctx, "wait_for_batch", payload)
+
+
+@batch_app.command("list")
+def list_jobs(
+    ctx: typer.Context,
+    status: Optional[str] = typer.Option(None, "--status", help="queued|processing|completed|failed|cancelled."),
+    start_date: Optional[str] = typer.Option(None, "--start-date", help="ISO 8601 lower bound."),
+    end_date: Optional[str] = typer.Option(None, "--end-date", help="ISO 8601 upper bound."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(100, "--page-size", help="Results per page (max 100)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """List and filter batch jobs."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        ListBatchJobsInput,
+        page=page,
+        page_size=page_size,
+        **optional(status=status, start_date=start_date, end_date=end_date),
+    )
+    call(ctx, "list_batch_jobs", payload)
+
+
+@batch_app.command("cancel")
+def cancel(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Batch job ID to cancel."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Cancel a running batch job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    call(ctx, "cancel_batch", {"job_id": job_id})

geonode_scraper_cli/commands/config.py

@@ -0,0 +1,48 @@
+"""`gscraper config` — inspect CLI configuration (read-only)."""
+
+from __future__ import annotations
+
+import typer
+
+from ..config import ConfigError, config_path, load_profiles, resolve_profile_name
+from ..context import get_cli_context
+from ..errors import ExitCode
+from ..renderers import console
+
+config_app = typer.Typer(help="Inspect CLI configuration.", no_args_is_help=True)
+
+
+@config_app.command("path")
+def path() -> None:
+    """Print the location of the TOML config file."""
+    typer.echo(str(config_path()))
+
+
+@config_app.command("show")
+def show(ctx: typer.Context) -> None:
+    """Show the active profile and config file contents (API keys masked)."""
+    cli = get_cli_context(ctx)
+    profile = resolve_profile_name(cli.profile)
+    try:
+        profiles = load_profiles()
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(int(ExitCode.USAGE)) from exc
+
+    out = console()
+    out.print(f"config file: {config_path()}")
+    out.print(f"active profile: {profile}")
+    if not profiles:
+        out.print("[yellow]No config file found.[/yellow]")
+        return
+    masked = {name: _mask(section) for name, section in profiles.items()}
+    out.print_json(data=masked)
+
+
+def _mask(section: object) -> object:
+    if not isinstance(section, dict):
+        return section
+    redacted = dict(section)
+    if "api_key" in redacted and redacted["api_key"]:
+        redacted["api_key"] = "***"
+    return redacted

geonode_scraper_cli/commands/crawl.py

@@ -0,0 +1,119 @@
+"""`gscraper crawl` — submit and manage site crawl jobs."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import (
+    CreateCrawlInput,
+    GetCrawlStatusInput,
+    ListCrawlJobsInput,
+    WaitForCrawlInput,
+)
+
+from ..invoke import call, validated
+from ._common import apply_output_override, optional
+
+crawl_app = typer.Typer(help="Submit and manage site crawl jobs.", no_args_is_help=True)
+
+
+@crawl_app.command("create")
+def create(
+    ctx: typer.Context,
+    url: str = typer.Argument(..., help="Seed URL to start crawling from."),
+    depth: int = typer.Option(2, "--depth", help="Maximum crawl depth."),
+    limit: int = typer.Option(50, "--limit", help="Maximum number of pages."),
+    formats: Optional[List[str]] = typer.Option(None, "--format", "-f", help="Output format(s). Repeatable."),
+    render_js: bool = typer.Option(False, "--render-js", help="Render JavaScript with a headless browser."),
+    same_domain_only: bool = typer.Option(
+        True, "--same-domain-only/--all-domains", help="Restrict to the seed domain."
+    ),
+    include_subdomains: bool = typer.Option(False, "--include-subdomains", help="Include subdomains when crawling."),
+    proxy_country: Optional[str] = typer.Option(None, "--proxy-country", help="ISO 3166-1 alpha-2 country code."),
+    proxy_type: Optional[str] = typer.Option(None, "--proxy-type", help="Proxy type: datacenter, residential, mix."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Crawl a website from a seed URL up to a depth and page limit."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        CreateCrawlInput,
+        url=url,
+        depth=depth,
+        limit=limit,
+        render_js=render_js,
+        same_domain_only=same_domain_only,
+        include_subdomains=include_subdomains,
+        **optional(formats=formats, proxy_country=proxy_country, proxy_type=proxy_type),
+    )
+    call(ctx, "create_crawl", payload)
+
+
+@crawl_app.command("status")
+def status(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Crawl job ID."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(10, "--page-size", help="Results per page (max 50)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Show the status and per-page results of a crawl job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(GetCrawlStatusInput, job_id=job_id, page=page, page_size=page_size)
+    call(ctx, "get_crawl_status", payload)
+
+
+@crawl_app.command("wait")
+def wait(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Crawl job ID."),
+    timeout_seconds: Optional[float] = typer.Option(None, "--timeout", help="Polling timeout override (seconds)."),
+    poll_interval_seconds: Optional[float] = typer.Option(None, "--interval", help="Polling interval override (s)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Poll a crawl job until it reaches a terminal state."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        WaitForCrawlInput,
+        job_id=job_id,
+        **optional(timeout_seconds=timeout_seconds, poll_interval_seconds=poll_interval_seconds),
+    )
+    call(ctx, "wait_for_crawl", payload)
+
+
+@crawl_app.command("list")
+def list_jobs(
+    ctx: typer.Context,
+    url: Optional[str] = typer.Option(None, "--url", help="Filter by seed URL."),
+    status: Optional[str] = typer.Option(None, "--status", help="queued|processing|completed|failed|cancelled."),
+    start_date: Optional[str] = typer.Option(None, "--start-date", help="ISO 8601 lower bound."),
+    end_date: Optional[str] = typer.Option(None, "--end-date", help="ISO 8601 upper bound."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(100, "--page-size", help="Results per page (max 100)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """List and filter crawl jobs."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        ListCrawlJobsInput,
+        page=page,
+        page_size=page_size,
+        **optional(url=url, status=status, start_date=start_date, end_date=end_date),
+    )
+    call(ctx, "list_crawl_jobs", payload)
+
+
+@crawl_app.command("cancel")
+def cancel(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Crawl job ID to cancel."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Cancel a running crawl job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    call(ctx, "cancel_crawl", {"job_id": job_id})

geonode_scraper_cli/commands/extract.py

@@ -0,0 +1,78 @@
+"""`gscraper extract` — extract content from a single URL."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import ExtractInput
+
+from ..context import get_cli_context
+from ..errors import ExitCode
+from ..invoke import call, validated
+from ..renderers import emit
+from ._common import apply_output_override, optional, parse_headers
+
+
+def extract(
+    ctx: typer.Context,
+    url: str = typer.Argument(..., help="URL to extract content from."),
+    formats: Optional[List[str]] = typer.Option(
+        None, "--format", "-f", help="Output format(s): markdown, html. Repeatable."
+    ),
+    render_js: bool = typer.Option(False, "--render-js", help="Render JavaScript with a headless browser."),
+    is_async: bool = typer.Option(False, "--async", "-a", help="Submit as an async job instead of waiting inline."),
+    proxy_country: Optional[str] = typer.Option(None, "--proxy-country", help="ISO 3166-1 alpha-2 country code."),
+    proxy_type: Optional[str] = typer.Option(None, "--proxy-type", help="Proxy type: datacenter, residential, mix."),
+    header: Optional[List[str]] = typer.Option(None, "--header", "-H", help="Request header 'Key: Value'. Repeatable."),
+    wait_for: Optional[str] = typer.Option(
+        None, "--wait-for", help="CSS/XPath selector to wait for (browser only, requires --render-js)."
+    ),
+    wait_timeout: Optional[int] = typer.Option(
+        None, "--wait-timeout", help="Pause in ms after wait_for (0-30000, requires --render-js)."
+    ),
+    wait_until: Optional[str] = typer.Option(
+        None, "--wait-until", help="Lifecycle event: load, networkidle, ... (requires --render-js)."
+    ),
+    output_file: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Write the extracted content (markdown/html) to this file."
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Extract content from URL. Sync by default; use --async to queue a job."""
+    apply_output_override(ctx, as_json, as_yaml)
+
+    if (wait_for is not None or wait_timeout is not None or wait_until is not None) and not render_js:
+        typer.echo("--wait-for, --wait-until, and --wait-timeout require --render-js.", err=True)
+        raise typer.Exit(int(ExitCode.USAGE))
+
+    payload = validated(
+        ExtractInput,
+        url=url,
+        render_js=render_js,
+        processing_mode="async" if is_async else "sync",
+        **optional(
+            formats=formats,
+            proxy_country=proxy_country,
+            proxy_type=proxy_type,
+            headers=parse_headers(header),
+            wait_for=wait_for,
+            wait_timeout=wait_timeout,
+            wait_until=wait_until,
+        ),
+    )
+
+    if output_file is None:
+        call(ctx, "extract", payload)
+
+    # --output: call once, write the content body, then emit the same envelope.
+    cli = get_cli_context(ctx)
+    result = cli.service().extract(**payload)
+    if result.get("ok"):
+        data = (result.get("result") or {}).get("data") or {}
+        content = data.get("markdown") or data.get("html") or ""
+        output_file.write_text(content, encoding="utf-8")
+        typer.echo(f"Wrote {len(content)} chars to {output_file}", err=True)
+    emit(cli.output, result)

geonode_scraper_cli/commands/jobs.py

@@ -0,0 +1,77 @@
+"""`gscraper jobs` — inspect and wait on extraction jobs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import GetJobResultInput, ListJobsInput, WaitForJobInput
+
+from ..invoke import call, validated
+from ._common import apply_output_override, optional
+
+jobs_app = typer.Typer(help="Inspect and wait on extraction jobs.", no_args_is_help=True)
+
+
+@jobs_app.command("get")
+def get(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Extraction job ID."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Fetch the current state or final result of an extraction job."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(GetJobResultInput, job_id=job_id)
+    call(ctx, "get_job_result", payload)
+
+
+@jobs_app.command("list")
+def list_jobs(
+    ctx: typer.Context,
+    job_id: Optional[str] = typer.Option(None, "--job-id", help="Filter by job ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="Filter by target URL."),
+    status: Optional[str] = typer.Option(None, "--status", help="queued|processing|completed|failed|cancelled."),
+    output: Optional[str] = typer.Option(None, "--output-format", help="Filter by requested output: markdown|html."),
+    start_date: Optional[str] = typer.Option(None, "--start-date", help="ISO 8601 lower bound."),
+    end_date: Optional[str] = typer.Option(None, "--end-date", help="ISO 8601 upper bound."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(100, "--page-size", help="Results per page (max 100)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """List and filter extraction jobs."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        ListJobsInput,
+        page=page,
+        page_size=page_size,
+        **optional(
+            job_id=job_id,
+            url=url,
+            status=status,
+            output=output,
+            start_date=start_date,
+            end_date=end_date,
+        ),
+    )
+    call(ctx, "list_jobs", payload)
+
+
+@jobs_app.command("wait")
+def wait(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Extraction job ID."),
+    timeout_seconds: Optional[float] = typer.Option(None, "--timeout", help="Polling timeout override (seconds)."),
+    poll_interval_seconds: Optional[float] = typer.Option(None, "--interval", help="Polling interval override (s)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Poll an extraction job until it reaches a terminal state."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        WaitForJobInput,
+        job_id=job_id,
+        **optional(timeout_seconds=timeout_seconds, poll_interval_seconds=poll_interval_seconds),
+    )
+    call(ctx, "wait_for_job", payload)

geonode_scraper_cli/commands/map.py

@@ -0,0 +1,75 @@
+"""`gscraper map` — discover URLs under a base URL."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import GetMapJobInput, ListMapJobsInput, MapUrlsInput
+
+from ..invoke import call, validated
+from ._common import apply_output_override, optional
+
+map_app = typer.Typer(help="Discover URLs under a base URL.", no_args_is_help=True)
+map_jobs_app = typer.Typer(help="Inspect map jobs.", no_args_is_help=True)
+map_app.add_typer(map_jobs_app, name="jobs")
+
+
+@map_app.command("run")
+def run(
+    ctx: typer.Context,
+    url: str = typer.Argument(..., help="Base URL to discover links from."),
+    search: Optional[str] = typer.Option(None, "--search", help="Filter discovered links by substring."),
+    include_subdomains: bool = typer.Option(True, "--include-subdomains/--no-subdomains", help="Include subdomains."),
+    ignore_query_parameters: bool = typer.Option(
+        True, "--ignore-query/--keep-query", help="Ignore query parameters when de-duplicating links."
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Discover all URLs under a base URL (returns synchronously)."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        MapUrlsInput,
+        url=url,
+        include_subdomains=include_subdomains,
+        ignore_query_parameters=ignore_query_parameters,
+        **optional(search=search),
+    )
+    call(ctx, "map_urls", payload)
+
+
+@map_jobs_app.command("list")
+def list_jobs(
+    ctx: typer.Context,
+    url: Optional[str] = typer.Option(None, "--url", help="Filter by base URL."),
+    status: Optional[str] = typer.Option(None, "--status", help="queued|processing|completed|failed|cancelled."),
+    start_date: Optional[str] = typer.Option(None, "--start-date", help="ISO 8601 lower bound."),
+    end_date: Optional[str] = typer.Option(None, "--end-date", help="ISO 8601 upper bound."),
+    page: int = typer.Option(1, "--page", help="Page number."),
+    page_size: int = typer.Option(100, "--page-size", help="Results per page (max 100)."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """List and filter map jobs."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(
+        ListMapJobsInput,
+        page=page,
+        page_size=page_size,
+        **optional(url=url, status=status, start_date=start_date, end_date=end_date),
+    )
+    call(ctx, "list_map_jobs", payload)
+
+
+@map_jobs_app.command("get")
+def get(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Map job ID."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Fetch a single map job by ID."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(GetMapJobInput, job_id=job_id)
+    call(ctx, "get_map_job", payload)

geonode_scraper_cli/commands/stats.py

@@ -0,0 +1,24 @@
+"""`gscraper stats` — usage statistics."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from geonode_scraper_tools_core.schemas import GetStatisticsInput
+
+from ..invoke import call, validated
+from ._common import apply_output_override, optional
+
+
+def stats(
+    ctx: typer.Context,
+    start_date: Optional[str] = typer.Option(None, "--start-date", help="ISO 8601 lower bound."),
+    end_date: Optional[str] = typer.Option(None, "--end-date", help="ISO 8601 upper bound."),
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Show usage statistics for an optional date range."""
+    apply_output_override(ctx, as_json, as_yaml)
+    payload = validated(GetStatisticsInput, **optional(start_date=start_date, end_date=end_date))
+    call(ctx, "get_statistics", payload)

geonode_scraper_cli/commands/system.py

@@ -0,0 +1,18 @@
+"""`gscraper health` — API health check."""
+
+from __future__ import annotations
+
+import typer
+
+from ..invoke import call
+from ._common import apply_output_override
+
+
+def health(
+    ctx: typer.Context,
+    as_json: bool = typer.Option(False, "--json", help="Output raw JSON envelope."),
+    as_yaml: bool = typer.Option(False, "--yaml", help="Output raw YAML envelope."),
+) -> None:
+    """Check the Scraper API health endpoint."""
+    apply_output_override(ctx, as_json, as_yaml)
+    call(ctx, "health_check", {})