webextrator-cli 2026.7.1.0__py3-none-any.whl

webextrator_cli/__init__.py

@@ -0,0 +1,3 @@
+"""WebExtrator CLI package."""
+
+__version__ = "0.1.0"

webextrator_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m webextrator_cli."""
+
+from webextrator_cli.main import cli
+
+if __name__ == "__main__":
+    cli()

webextrator_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""WebExtrator CLI commands package."""

webextrator_cli/commands/info.py

@@ -0,0 +1,25 @@
+"""Info and utility commands."""
+
+import click
+
+from webextrator_cli.core.config import settings
+from webextrator_cli.core.output import console
+
+
+@click.command()
+def config() -> None:
+    """Show current configuration."""
+    from rich.table import Table
+
+    table = Table(title="WebExtrator CLI Configuration")
+    table.add_column("Setting", style="bold cyan")
+    table.add_column("Value")
+
+    table.add_row("API Base URL", settings.api_base_url)
+    table.add_row(
+        "API Token",
+        f"{settings.api_token[:8]}..." if settings.api_token else "[red]Not set[/red]",
+    )
+    table.add_row("Request Timeout", f"{settings.request_timeout}s")
+
+    console.print(table)

webextrator_cli/commands/task.py

@@ -0,0 +1,101 @@
+"""Task management commands for WebExtrator."""
+
+import click
+
+from webextrator_cli.core.client import get_client
+from webextrator_cli.core.exceptions import WebExtratorError
+from webextrator_cli.core.output import print_error, print_json, print_task_result
+
+
+@click.group()
+def tasks() -> None:
+    """Query previously created render/extract tasks.
+
+    \b
+    Examples:
+      webextrator tasks retrieve --id 550e8400-e29b-41d4-a716-446655440000
+      webextrator tasks retrieve --trace-id 550e8400-e29b-41d4-a716-446655440001
+      webextrator tasks batch --ids id1 id2
+    """
+
+
+@tasks.command()
+@click.option("--id", "task_id", default=None, help="Task UUID to retrieve.")
+@click.option("--trace-id", default=None, help="Trace UUID to retrieve.")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def retrieve(
+    ctx: click.Context,
+    task_id: str | None,
+    trace_id: str | None,
+    output_json: bool,
+) -> None:
+    """Retrieve a single render/extract task by ID or trace ID.
+
+    \b
+    Examples:
+      webextrator tasks retrieve --id 550e8400-e29b-41d4-a716-446655440000
+      webextrator tasks retrieve --trace-id 550e8400-e29b-41d4-a716-446655440001
+    """
+    if not task_id and not trace_id:
+        raise click.UsageError("Provide at least one of --id or --trace-id.")
+
+    client = get_client(ctx.obj.get("token"))
+    payload: dict[str, object] = {
+        "action": "retrieve",
+        "id": task_id,
+        "trace_id": trace_id,
+    }
+
+    try:
+        result = client.tasks(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_task_result(result)
+    except WebExtratorError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@tasks.command()
+@click.option("--ids", multiple=True, help="Task UUIDs to retrieve (repeatable).")
+@click.option("--trace-ids", multiple=True, help="Trace UUIDs to retrieve (repeatable).")
+@click.option("--offset", default=None, type=int, help="Pagination offset (default 0).")
+@click.option("--limit", default=None, type=int, help="Page size (default 12).")
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def batch(
+    ctx: click.Context,
+    ids: tuple[str, ...],
+    trace_ids: tuple[str, ...],
+    offset: int | None,
+    limit: int | None,
+    output_json: bool,
+) -> None:
+    """Retrieve multiple render/extract tasks at once.
+
+    \b
+    Examples:
+      webextrator tasks batch --ids id1 id2
+      webextrator tasks batch --trace-ids trace-001 trace-002
+      webextrator tasks batch --limit 5
+    """
+    client = get_client(ctx.obj.get("token"))
+    payload: dict[str, object] = {
+        "action": "retrieve_batch",
+        "ids": list(ids) if ids else None,
+        "trace_ids": list(trace_ids) if trace_ids else None,
+        "offset": offset,
+        "limit": limit,
+    }
+
+    try:
+        result = client.tasks(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_task_result(result)
+    except WebExtratorError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

webextrator_cli/commands/web.py

@@ -0,0 +1,252 @@
+"""Web extraction and rendering commands."""
+
+import json
+
+import click
+
+from webextrator_cli.core.client import get_client
+from webextrator_cli.core.exceptions import WebExtratorError
+from webextrator_cli.core.output import (
+    WAIT_UNTIL_OPTIONS,
+    print_error,
+    print_extract_result,
+    print_json,
+    print_render_result,
+)
+
+
+def _parse_headers(headers: str | None) -> dict[str, str] | None:
+    """Parse --headers JSON option."""
+    if headers is None:
+        return None
+    try:
+        parsed = json.loads(headers)
+    except json.JSONDecodeError as exc:
+        raise click.BadParameter("--headers must be a valid JSON object.") from exc
+    if not isinstance(parsed, dict) or not all(
+        isinstance(k, str) and isinstance(v, str) for k, v in parsed.items()
+    ):
+        raise click.BadParameter("--headers must be a JSON object of string key/value pairs.")
+    return parsed
+
+
+@click.command()
+@click.argument("url")
+@click.option(
+    "--expected-type",
+    type=click.Choice(["product", "article", "general"]),
+    default=None,
+    help="Hint about the expected page type to optimize extraction.",
+)
+@click.option(
+    "--enable-llm",
+    is_flag=True,
+    default=False,
+    help="Enable LLM-based semantic normalization as a final extraction step.",
+)
+@click.option(
+    "--wait-until",
+    type=click.Choice(WAIT_UNTIL_OPTIONS),
+    default=None,
+    help="Page load wait condition (default: networkidle).",
+)
+@click.option(
+    "--timeout",
+    default=None,
+    type=float,
+    help="Total timeout in seconds for the extract operation (default: 30).",
+)
+@click.option(
+    "--delay",
+    default=None,
+    type=float,
+    help="Extra delay in seconds after the page is loaded, before extraction.",
+)
+@click.option(
+    "--wait-for-selector",
+    default=None,
+    help="CSS selector to wait for before starting extraction.",
+)
+@click.option(
+    "--block-resources/--no-block-resources",
+    default=None,
+    help="Block non-essential resources (images/fonts/media) during page load.",
+)
+@click.option(
+    "--headers",
+    default=None,
+    help='Custom request headers as JSON, e.g. \'{"Accept-Language":"en-US"}\'.',
+)
+@click.option(
+    "--user-agent",
+    default=None,
+    help="Override the User-Agent header.",
+)
+@click.option(
+    "--callback-url",
+    default=None,
+    help="Callback URL for async processing.",
+)
+@click.option(
+    "--async",
+    "async_mode",
+    is_flag=True,
+    default=False,
+    help="Submit asynchronously; returns a task_id to poll instead of waiting.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def extract(
+    ctx: click.Context,
+    url: str,
+    expected_type: str | None,
+    enable_llm: bool,
+    wait_until: str | None,
+    timeout: float | None,
+    delay: float | None,
+    wait_for_selector: str | None,
+    block_resources: bool | None,
+    headers: str | None,
+    user_agent: str | None,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Extract structured content from a web page.
+
+    URL is the address of the web page to extract content from.
+
+    \b
+    Examples:
+      webextrator extract https://www.amazon.com/dp/B0C1234567
+      webextrator extract https://example.com/article --expected-type article
+      webextrator extract https://shop.example.com --enable-llm
+    """
+    client = get_client(ctx.obj.get("token"))
+    payload: dict[str, object] = {
+        "url": url,
+        "expected_type": expected_type,
+        "enable_llm": enable_llm if enable_llm else None,
+        "wait_until": wait_until,
+        "timeout": timeout,
+        "delay": delay,
+        "wait_for_selector": wait_for_selector,
+        "block_resources": block_resources,
+        "headers": _parse_headers(headers),
+        "user_agent": user_agent,
+        "callback_url": callback_url,
+        "async": async_mode,
+    }
+
+    try:
+        result = client.extract(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_extract_result(result)
+    except WebExtratorError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e
+
+
+@click.command()
+@click.argument("url")
+@click.option(
+    "--wait-until",
+    type=click.Choice(WAIT_UNTIL_OPTIONS),
+    default=None,
+    help="Page load wait condition (default: networkidle).",
+)
+@click.option(
+    "--timeout",
+    default=None,
+    type=float,
+    help="Total timeout in seconds for the render operation (default: 30).",
+)
+@click.option(
+    "--delay",
+    default=None,
+    type=float,
+    help="Extra delay in seconds after the page is loaded, before HTML is captured.",
+)
+@click.option(
+    "--wait-for-selector",
+    default=None,
+    help="CSS selector to wait for before capturing HTML.",
+)
+@click.option(
+    "--block-resources/--no-block-resources",
+    default=None,
+    help="Block non-essential resources (images/fonts/media) during page load.",
+)
+@click.option(
+    "--headers",
+    default=None,
+    help='Custom request headers as JSON, e.g. \'{"Accept-Language":"en-US"}\'.',
+)
+@click.option(
+    "--user-agent",
+    default=None,
+    help="Override the User-Agent header.",
+)
+@click.option(
+    "--callback-url",
+    default=None,
+    help="Callback URL for async processing.",
+)
+@click.option(
+    "--async",
+    "async_mode",
+    is_flag=True,
+    default=False,
+    help="Submit asynchronously; returns a task_id to poll instead of waiting.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output raw JSON.")
+@click.pass_context
+def render(
+    ctx: click.Context,
+    url: str,
+    wait_until: str | None,
+    timeout: float | None,
+    delay: float | None,
+    wait_for_selector: str | None,
+    block_resources: bool | None,
+    headers: str | None,
+    user_agent: str | None,
+    callback_url: str | None,
+    async_mode: bool,
+    output_json: bool,
+) -> None:
+    """Render a web page and return the rendered HTML.
+
+    URL is the address of the web page to render.
+
+    \b
+    Examples:
+      webextrator render https://example.com
+      webextrator render https://example.com --wait-until load
+      webextrator render https://spa.example.com --delay 2 --wait-for-selector "#app"
+    """
+    client = get_client(ctx.obj.get("token"))
+    payload: dict[str, object] = {
+        "url": url,
+        "wait_until": wait_until,
+        "timeout": timeout,
+        "delay": delay,
+        "wait_for_selector": wait_for_selector,
+        "block_resources": block_resources,
+        "headers": _parse_headers(headers),
+        "user_agent": user_agent,
+        "callback_url": callback_url,
+        "async": async_mode,
+    }
+
+    try:
+        result = client.render(**payload)  # type: ignore[arg-type]
+        if output_json:
+            print_json(result)
+        else:
+            print_render_result(result)
+    except WebExtratorError as e:
+        print_error(e.message)
+        raise SystemExit(1) from e

webextrator_cli/core/__init__.py

@@ -0,0 +1 @@
+"""WebExtrator CLI core package."""

webextrator_cli/core/client.py

@@ -0,0 +1,103 @@
+"""HTTP client for WebExtrator API."""
+
+from typing import Any
+
+import httpx
+
+from webextrator_cli.core.config import settings
+from webextrator_cli.core.exceptions import (
+    WebExtratorAPIError,
+    WebExtratorAuthError,
+    WebExtratorTimeoutError,
+)
+
+
+class WebExtratorClient:
+    """HTTP client for AceDataCloud WebExtrator API."""
+
+    def __init__(self, api_token: str | None = None, base_url: str | None = None):
+        self.api_token = api_token if api_token is not None else settings.api_token
+        self.base_url = base_url or settings.api_base_url
+        self.timeout = settings.request_timeout
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get request headers with authentication."""
+        if not self.api_token:
+            raise WebExtratorAuthError(
+                "API token not configured. Set ACEDATACLOUD_API_TOKEN or use --token option."
+            )
+        return {
+            "accept": "application/json",
+            "authorization": f"Bearer {self.api_token}",
+            "content-type": "application/json",
+        }
+
+    def request(
+        self,
+        endpoint: str,
+        payload: dict[str, Any],
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        """Make a POST request to the WebExtrator API."""
+        url = f"{self.base_url}{endpoint}"
+        request_timeout = timeout or self.timeout
+
+        # Remove None values from payload
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        with httpx.Client() as http_client:
+            try:
+                response = http_client.post(
+                    url,
+                    json=payload,
+                    headers=self._get_headers(),
+                    timeout=request_timeout,
+                )
+
+                if response.status_code == 401:
+                    raise WebExtratorAuthError("Invalid API token")
+
+                if response.status_code == 403:
+                    raise WebExtratorAuthError("Access denied. Check your API permissions.")
+
+                response.raise_for_status()
+                return response.json()  # type: ignore[no-any-return]
+
+            except httpx.TimeoutException as e:
+                raise WebExtratorTimeoutError(
+                    f"Request to {endpoint} timed out after {request_timeout}s"
+                ) from e
+
+            except WebExtratorAuthError:
+                raise
+
+            except httpx.HTTPStatusError as e:
+                raise WebExtratorAPIError(
+                    message=e.response.text,
+                    code=f"http_{e.response.status_code}",
+                    status_code=e.response.status_code,
+                ) from e
+
+            except Exception as e:
+                if isinstance(e, WebExtratorAPIError | WebExtratorTimeoutError):
+                    raise
+                raise WebExtratorAPIError(message=str(e)) from e
+
+    def extract(self, **kwargs: Any) -> dict[str, Any]:
+        """Extract structured content from a web page."""
+        return self.request("/webextrator/extract", kwargs)
+
+    def render(self, **kwargs: Any) -> dict[str, Any]:
+        """Render a web page and return the HTML."""
+        return self.request("/webextrator/render", kwargs)
+
+    def tasks(self, **kwargs: Any) -> dict[str, Any]:
+        """Query previously created render/extract tasks."""
+        return self.request("/webextrator/tasks", kwargs)
+
+
+def get_client(token: str | None = None) -> WebExtratorClient:
+    """Get a WebExtratorClient instance, optionally overriding the token."""
+    if token:
+        return WebExtratorClient(api_token=token)
+    return WebExtratorClient()

webextrator_cli/core/config.py

@@ -0,0 +1,39 @@
+"""Configuration management for WebExtrator CLI."""
+
+import os
+from dataclasses import dataclass, field
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Settings:
+    """Application settings loaded from environment variables."""
+
+    api_base_url: str = field(
+        default_factory=lambda: os.environ.get(
+            "ACEDATACLOUD_API_BASE_URL", "https://api.acedata.cloud"
+        )
+    )
+    api_token: str = field(default_factory=lambda: os.environ.get("ACEDATACLOUD_API_TOKEN", ""))
+    request_timeout: float = field(
+        default_factory=lambda: float(os.environ.get("WEBEXTRATOR_REQUEST_TIMEOUT", "60"))
+    )
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if the API token is configured."""
+        return bool(self.api_token)
+
+    def validate(self) -> None:
+        """Validate configuration. Raises ValueError if API token is missing."""
+        if not self.api_token:
+            raise ValueError(
+                "API token not configured. "
+                "Set ACEDATACLOUD_API_TOKEN environment variable or use --token option."
+            )
+
+
+settings = Settings()

webextrator_cli/core/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for WebExtrator CLI."""
+
+
+class WebExtratorError(Exception):
+    """Base exception for WebExtrator CLI."""
+
+    def __init__(self, message: str, code: str = "unknown"):
+        self.message = message
+        self.code = code
+        super().__init__(message)
+
+
+class WebExtratorAuthError(WebExtratorError):
+    """Authentication error."""
+
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, code="auth_error")
+
+
+class WebExtratorAPIError(WebExtratorError):
+    """API error with HTTP status code."""
+
+    def __init__(
+        self,
+        message: str = "API request failed",
+        code: str = "api_error",
+        status_code: int | None = None,
+    ):
+        self.status_code = status_code
+        super().__init__(message, code)
+
+
+class WebExtratorTimeoutError(WebExtratorError):
+    """Request timeout error."""
+
+    def __init__(self, message: str = "Request timed out"):
+        super().__init__(message, code="timeout_error")

webextrator_cli/core/output.py

@@ -0,0 +1,114 @@
+"""Rich terminal output formatting for WebExtrator CLI."""
+
+import json
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Wait-until options
+WAIT_UNTIL_OPTIONS = ["load", "domcontentloaded", "networkidle", "commit"]
+
+# Block resource types
+BLOCK_RESOURCE_TYPES = ["image", "font", "media", "stylesheet", "xhr", "fetch"]
+
+
+def print_json(data: Any) -> None:
+    """Print data as formatted JSON."""
+    click.echo(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]\u2713[/bold green] {message}")
+
+
+def print_extract_result(data: dict[str, Any]) -> None:
+    """Print an extract result in a rich format."""
+    task_id = data.get("task_id", "N/A")
+    trace_id = data.get("trace_id", "N/A")
+    elapsed = data.get("elapsed", "N/A")
+    result_data = data.get("data", {})
+
+    console.print(
+        Panel(
+            f"[bold]Task ID:[/bold] {task_id}\n"
+            f"[bold]Trace ID:[/bold] {trace_id}\n"
+            f"[bold]Elapsed:[/bold] {elapsed}s",
+            title="[bold green]Extract Result[/bold green]",
+            border_style="green",
+        )
+    )
+
+    if result_data and isinstance(result_data, dict):
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Field", style="bold cyan", width=15)
+        table.add_column("Value")
+        for key in ["url", "contentType", "title", "description", "siteName"]:
+            if result_data.get(key):
+                table.add_row(key, str(result_data[key]))
+        console.print(table)
+
+
+def print_render_result(data: dict[str, Any]) -> None:
+    """Print a render result in a rich format."""
+    task_id = data.get("task_id", "N/A")
+    trace_id = data.get("trace_id", "N/A")
+    elapsed = data.get("elapsed", "N/A")
+    result_data = data.get("data", {})
+
+    console.print(
+        Panel(
+            f"[bold]Task ID:[/bold] {task_id}\n"
+            f"[bold]Trace ID:[/bold] {trace_id}\n"
+            f"[bold]Elapsed:[/bold] {elapsed}s",
+            title="[bold green]Render Result[/bold green]",
+            border_style="green",
+        )
+    )
+
+    if result_data and isinstance(result_data, dict):
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Field", style="bold cyan", width=15)
+        table.add_column("Value")
+        for key in ["url", "finalUrl", "title", "status"]:
+            if result_data.get(key) is not None:
+                table.add_row(key, str(result_data[key]))
+        html = result_data.get("html", "")
+        if html:
+            table.add_row("HTML length", f"{len(html)} chars")
+        console.print(table)
+
+
+def print_task_result(data: dict[str, Any]) -> None:
+    """Print task query result in a rich format."""
+    items = data.get("items")
+    if items is not None:
+        # Batch result
+        count = data.get("count", len(items))
+        console.print(f"[bold]Tasks found:[/bold] {count}")
+        for item in items:
+            _print_single_task(item)
+    else:
+        _print_single_task(data)
+
+
+def _print_single_task(task_data: dict[str, Any]) -> None:
+    """Print a single task row."""
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Field", style="bold cyan", width=15)
+    table.add_column("Value")
+    for key in ["id", "task_id", "trace_id", "type", "started_at", "finished_at", "elapsed"]:
+        if task_data.get(key) is not None:
+            table.add_row(key.replace("_", " ").title(), str(task_data[key]))
+    console.print(table)
+    console.print()

webextrator_cli/main.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+WebExtrator CLI - Web Render & Extract via AceDataCloud.
+
+A command-line tool for extracting structured content and rendering web pages
+powered by AceDataCloud.
+"""
+
+from importlib import metadata
+
+import click
+from dotenv import load_dotenv
+
+from webextrator_cli.commands.info import config
+from webextrator_cli.commands.task import tasks
+from webextrator_cli.commands.web import extract, render
+
+load_dotenv()
+
+
+def get_version() -> str:
+    """Get the package version."""
+    try:
+        return metadata.version("webextrator-cli")
+    except metadata.PackageNotFoundError:
+        return "dev"
+
+
+@click.group()
+@click.version_option(version=get_version(), prog_name="webextrator-cli")
+@click.option(
+    "--token",
+    envvar="ACEDATACLOUD_API_TOKEN",
+    help="API token (or set ACEDATACLOUD_API_TOKEN env var).",
+)
+@click.pass_context
+def cli(ctx: click.Context, token: str | None) -> None:
+    """WebExtrator CLI - Web Render & Extract via AceDataCloud.
+
+    Extract structured data and render web pages from the command line.
+
+    Get your API token at https://platform.acedata.cloud
+
+    \b
+    Examples:
+      webextrator extract https://www.amazon.com/dp/B0C1234567
+      webextrator render https://example.com
+      webextrator tasks retrieve --id <task-id>
+
+    Set your token:
+      export ACEDATACLOUD_API_TOKEN=your_token
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["token"] = token
+
+
+# Register commands
+cli.add_command(extract)
+cli.add_command(render)
+cli.add_command(tasks)
+cli.add_command(config)
+
+
+if __name__ == "__main__":
+    cli()

webextrator_cli-2026.7.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: webextrator-cli
+Version: 2026.7.1.0
+Summary: CLI tool for WebExtrator Web Render & Extract via AceDataCloud
+Project-URL: Homepage, https://github.com/AceDataCloud/Clis
+Project-URL: Repository, https://github.com/AceDataCloud/Clis
+Project-URL: Issues, https://github.com/AceDataCloud/Clis/issues
+Project-URL: Changelog, https://github.com/AceDataCloud/Clis/blob/main/webextrator/CHANGELOG.md
+Author-email: AceDataCloud <support@acedata.cloud>
+Maintainer-email: AceDataCloud <support@acedata.cloud>
+License: MIT
+License-File: LICENSE
+Keywords: acedata,cli,command-line,web-rendering,web-scraping,webextrator
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: all
+Requires-Dist: webextrator-cli[dev,release,test]; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: release
+Requires-Dist: build>=1.2.0; extra == 'release'
+Requires-Dist: twine>=6.1.0; extra == 'release'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Requires-Dist: respx>=0.21.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# WebExtrator CLI
+
+A command-line tool for web rendering and extraction via [AceDataCloud](https://platform.acedata.cloud).
+
+## Installation
+
+```bash
+pip install webextrator-cli
+```
+
+## Quick Start
+
+```bash
+export ACEDATACLOUD_API_TOKEN=your_token
+
+webextrator extract https://www.amazon.com/dp/B0C1234567
+webextrator render https://example.com
+webextrator tasks retrieve --id <task-id>
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `webextrator extract <url>` | Extract structured content from a web page |
+| `webextrator render <url>` | Render a web page and return the HTML |
+| `webextrator tasks retrieve` | Retrieve a single task by ID or trace ID |
+| `webextrator tasks batch` | Retrieve multiple tasks at once |
+| `webextrator config` | Show current configuration |
+
+## Global Options
+
+```
+--token TEXT    API token (or set ACEDATACLOUD_API_TOKEN env var)
+--version       Show version
+--help          Show help message
+```
+
+## Configuration
+
+Set environment variables or use a `.env` file:
+
+```bash
+ACEDATACLOUD_API_TOKEN=your_token
+ACEDATACLOUD_API_BASE_URL=https://api.acedata.cloud
+WEBEXTRATOR_REQUEST_TIMEOUT=60
+```
+
+## License
+
+MIT

webextrator_cli-2026.7.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+webextrator_cli/__init__.py,sha256=hnkmABdt_nUDcRh7s_qnlbryMOmL9WOK5vdlfGONikY,54
+webextrator_cli/__main__.py,sha256=UwsREVewLZPy5FMKrTsVjYcLdG--PNDesfI4h3roFZM,125
+webextrator_cli/main.py,sha256=01F3HwlNU1S3PJ5yaYLaZkUq63y65KGh_WqceblhvB8,1587
+webextrator_cli/commands/__init__.py,sha256=yPsetRwqRP3ugV3tdPAGSdUHNN9hsHIN4qAUNqyHDk4,40
+webextrator_cli/commands/info.py,sha256=nf05whSwk0oC9HvbEXqGcjjwtJCY5zPENlnw-F9xiaQ,683
+webextrator_cli/commands/task.py,sha256=UzY_ahz-7j_6fUkzzAVcX5UODwo4dYNeHQp7cSZTz4I,3218
+webextrator_cli/commands/web.py,sha256=EWK_lT4XRsZoUXWwzdLRPo_gghDlMhcJ62QI1iYfTc0,6958
+webextrator_cli/core/__init__.py,sha256=keeJu-Y-FrpTbLSJjVHUGywB_xtvn2ZJledaoNpVWmI,36
+webextrator_cli/core/client.py,sha256=2J5R1IL5jq-DWR-PJQbYxf5szkeo69RZ0SxKodz909I,3637
+webextrator_cli/core/config.py,sha256=fy2RHL4OdkFdy4Xz-Oi9f9RtfwrZDulruTinNKt7UH0,1128
+webextrator_cli/core/exceptions.py,sha256=FtI9U97z24kKRiaxe8E5CMkCb8YPkOKLgCNpm1FSC0o,1006
+webextrator_cli/core/output.py,sha256=NNBIvWjZBZPRoW2t4auuR309hwvBs1pdzwN_NSmO2i0,3839
+webextrator_cli-2026.7.1.0.dist-info/METADATA,sha256=yUnaD2J8a9ShQcTqVh6w-NM3BnIUhCvezfLL_bhIWQk,3134
+webextrator_cli-2026.7.1.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+webextrator_cli-2026.7.1.0.dist-info/entry_points.txt,sha256=dI54Jr_ZMP_WLzmKdpOsK2zV9uEPD9ubC-IQKiOscyk,100
+webextrator_cli-2026.7.1.0.dist-info/licenses/LICENSE,sha256=pi1I0LFwS_WQBwOlBks6BkKATEJxYi54t8Q22FQ7ufo,1069
+webextrator_cli-2026.7.1.0.dist-info/RECORD,,

webextrator_cli-2026.7.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.21.1
+Root-Is-Purelib: true
+Tag: py3-none-any

webextrator_cli-2026.7.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+webextrator = webextrator_cli.main:cli
+webextrator-cli = webextrator_cli.main:cli

webextrator_cli-2026.7.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AceDataCloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.