discolike-cli 0.1.0__tar.gz

discolike_cli-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+.venv/
+dist/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/

discolike_cli-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: discolike-cli
+Version: 0.1.0
+Summary: Official CLI for the DiscoLike API
+Project-URL: Homepage, https://www.discolike.com
+Project-URL: Documentation, https://docs.discolike.com
+Project-URL: Repository, https://github.com/Discolike/discolike-python
+Author-email: DiscoLike <support@discolike.com>
+License-Expression: MIT
+Keywords: business-data,cli,discolike,enrichment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: discolike>=0.1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# discolike-cli
+
+Official CLI for the [DiscoLike API](https://www.discolike.com) — the `discolike` command from your terminal. Built on the [`discolike`](https://pypi.org/project/discolike/) SDK.
+
+## Installation
+
+```bash
+pip install discolike-cli
+```
+
+Or run it without installing:
+
+```bash
+uvx --from discolike-cli discolike --help
+```
+
+Requires Python 3.10+. Installing this package gives you the `discolike` command.
+
+## Authentication
+
+```bash
+discolike auth login
+```
+
+Prompts for an API key (or pass `--api-key`) and verifies it against your account. Create a key at [app.discolike.com/account/management/keys](https://app.discolike.com/account/management/keys). You can also set `DISCOLIKE_API_KEY` in the environment instead.
+
+## Quickstart
+
+```bash
+discolike discover --icp-text "managed IT services for SMBs" --country US --max-records 25
+discolike match "Stripe Inc" --city "San Francisco"
+discolike match --file companies.csv --name-column company_name --wait
+discolike count --phrase-match "book a demo" --country US
+discolike company data stripe.com
+discolike extract https://stripe.com/enterprise
+```
+
+Top-level commands: `discover`, `count`, `match`, `extract`, `validate-icp`, `append`, `segment` — plus `auth`, `company`, `contacts`, `discogen`, `queries`, and `account` command groups.
+
+### Conventions
+
+- Results print as JSON to stdout; errors print as JSON (`error`, `message`, `status_code`) to stderr.
+- Pass `--format table` for a human-readable table — used automatically when stdout is a TTY.
+- Async endpoints (`match --file`, `discogen run`, `discogen run-personas`, `segment`, `validate-icp`) take `--wait` to block until the job finishes. Without it, you get a `task_id` back to poll with `discolike discogen status <task_id> --family <family>`. `append` is synchronous — it returns enriched rows directly (or writes CSV bytes to `--output`).
+
+### Exit codes
+
+| Exit code | Meaning |
+|---|---|
+| 0 | Success |
+| 1 | Server error or unexpected failure |
+| 2 | Validation error |
+| 3 | Authentication or plan-access error |
+| 4 | Rate limited |
+| 5 | Network error |
+| 6 | Not found |
+
+## Links
+
+- **API documentation**: [docs.discolike.com](https://docs.discolike.com)
+- **Source**: [github.com/Discolike/discolike-python](https://github.com/Discolike/discolike-python)
+
+## License
+
+[MIT](https://github.com/Discolike/discolike-python/blob/main/LICENSE)

discolike_cli-0.1.0/README.md

@@ -0,0 +1,65 @@
+# discolike-cli
+
+Official CLI for the [DiscoLike API](https://www.discolike.com) — the `discolike` command from your terminal. Built on the [`discolike`](https://pypi.org/project/discolike/) SDK.
+
+## Installation
+
+```bash
+pip install discolike-cli
+```
+
+Or run it without installing:
+
+```bash
+uvx --from discolike-cli discolike --help
+```
+
+Requires Python 3.10+. Installing this package gives you the `discolike` command.
+
+## Authentication
+
+```bash
+discolike auth login
+```
+
+Prompts for an API key (or pass `--api-key`) and verifies it against your account. Create a key at [app.discolike.com/account/management/keys](https://app.discolike.com/account/management/keys). You can also set `DISCOLIKE_API_KEY` in the environment instead.
+
+## Quickstart
+
+```bash
+discolike discover --icp-text "managed IT services for SMBs" --country US --max-records 25
+discolike match "Stripe Inc" --city "San Francisco"
+discolike match --file companies.csv --name-column company_name --wait
+discolike count --phrase-match "book a demo" --country US
+discolike company data stripe.com
+discolike extract https://stripe.com/enterprise
+```
+
+Top-level commands: `discover`, `count`, `match`, `extract`, `validate-icp`, `append`, `segment` — plus `auth`, `company`, `contacts`, `discogen`, `queries`, and `account` command groups.
+
+### Conventions
+
+- Results print as JSON to stdout; errors print as JSON (`error`, `message`, `status_code`) to stderr.
+- Pass `--format table` for a human-readable table — used automatically when stdout is a TTY.
+- Async endpoints (`match --file`, `discogen run`, `discogen run-personas`, `segment`, `validate-icp`) take `--wait` to block until the job finishes. Without it, you get a `task_id` back to poll with `discolike discogen status <task_id> --family <family>`. `append` is synchronous — it returns enriched rows directly (or writes CSV bytes to `--output`).
+
+### Exit codes
+
+| Exit code | Meaning |
+|---|---|
+| 0 | Success |
+| 1 | Server error or unexpected failure |
+| 2 | Validation error |
+| 3 | Authentication or plan-access error |
+| 4 | Rate limited |
+| 5 | Network error |
+| 6 | Not found |
+
+## Links
+
+- **API documentation**: [docs.discolike.com](https://docs.discolike.com)
+- **Source**: [github.com/Discolike/discolike-python](https://github.com/Discolike/discolike-python)
+
+## License
+
+[MIT](https://github.com/Discolike/discolike-python/blob/main/LICENSE)

discolike_cli-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "discolike-cli"
+version = "0.1.0"
+description = "Official CLI for the DiscoLike API"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
+dependencies = [
+  "discolike>=0.1.0",
+  "typer>=0.12",
+  "rich>=13.0",
+]
+keywords = ["discolike", "cli", "business-data", "enrichment"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+
+[project.scripts]
+discolike = "discolike_cli.main:app"
+
+[project.urls]
+Homepage = "https://www.discolike.com"
+Documentation = "https://docs.discolike.com"
+Repository = "https://github.com/Discolike/discolike-python"
+
+[tool.uv.sources]
+discolike = { workspace = true }
+
+[dependency-groups]
+dev = [
+  "pytest>=8",
+  "pytest-asyncio>=0.24",
+  "ruff>=0.8",
+  "ty",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

discolike_cli-0.1.0/src/discolike_cli/_output.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import functools
+import json
+import sys
+from collections.abc import Callable
+from typing import Any
+from typing import ParamSpec
+from typing import Protocol
+from typing import TypeVar
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from discolike._exceptions import APIConnectionError
+from discolike._exceptions import AuthenticationError
+from discolike._exceptions import DiscolikeError
+from discolike._exceptions import NotFoundError
+from discolike._exceptions import PlanAccessError
+from discolike._exceptions import RateLimitError
+from discolike._exceptions import ValidationError
+from discolike._models import DiscolikeModel
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+EXIT_CODES: dict[type, int] = {
+    ValidationError: 2,
+    AuthenticationError: 3,
+    PlanAccessError: 3,
+    RateLimitError: 4,
+    APIConnectionError: 5,
+    NotFoundError: 6,
+}
+DEFAULT_EXIT_CODE = 1
+
+
+class _JobStatusLike(Protocol):
+    results: Any
+
+    @property
+    def progress(self) -> int | None: ...
+
+    def to_dict(self) -> dict[str, Any]: ...
+
+
+class SupportsWait(Protocol):
+    task_id: str
+    task_family: str
+
+    def wait(self, *, timeout: float, on_poll: Callable[[_JobStatusLike], None] | None = None) -> _JobStatusLike: ...
+
+
+def _normalize(data: Any) -> Any:  # noqa: ANN401 -- accepts arbitrary JSON-serializable CLI output data
+    if isinstance(data, DiscolikeModel):
+        return data.to_dict()
+    if isinstance(data, list):
+        return [item.to_dict() if isinstance(item, DiscolikeModel) else item for item in data]
+    return data
+
+
+def _is_flat_dict(value: Any) -> bool:  # noqa: ANN401 -- runtime-narrowed via isinstance, not a fixed shape
+    return isinstance(value, dict) and not any(isinstance(v, (dict, list)) for v in value.values())
+
+
+def _qualifies_for_table(data: Any) -> bool:  # noqa: ANN401 -- runtime-narrowed via isinstance, not a fixed shape
+    return isinstance(data, list) and len(data) > 0 and all(_is_flat_dict(item) for item in data)
+
+
+def _render_table(rows: list[dict[str, Any]]) -> None:
+    table = Table()
+    columns = list(rows[0].keys())
+    for column in columns:
+        table.add_column(column)
+    for row in rows:
+        table.add_row(*(str(row.get(column, "")) for column in columns))
+    Console().print(table)
+
+
+def emit(data: Any, *, fmt: str | None = None) -> None:  # noqa: ANN401 -- accepts arbitrary JSON-serializable CLI output data
+    normalized = _normalize(data)
+    want_table = fmt == "table" or (fmt is None and sys.stdout.isatty())
+    if want_table and _qualifies_for_table(normalized):
+        _render_table(normalized)
+        return
+    print(json.dumps(normalized, indent=2, default=str))
+
+
+def fail(exc: DiscolikeError) -> typer.Exit:
+    payload: dict[str, Any] = {
+        "error": type(exc).__name__,
+        "message": str(exc),
+        "status_code": exc.status_code,
+    }
+    if isinstance(exc, RateLimitError) and exc.retry_after is not None:
+        payload["retry_after"] = exc.retry_after
+    print(json.dumps(payload), file=sys.stderr)
+    return typer.Exit(code=EXIT_CODES.get(type(exc), DEFAULT_EXIT_CODE))
+
+
+def call_typed(fn: Callable[..., R], **kwargs: Any) -> R:  # noqa: ANN401 -- forwarded to a typed SDK method signature
+    try:
+        return fn(**kwargs)
+    except TypeError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+
+def handle_errors(fn: Callable[P, R]) -> Callable[P, R]:
+    @functools.wraps(fn)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return fn(*args, **kwargs)
+        except DiscolikeError as exc:
+            raise fail(exc) from exc
+
+    return wrapper
+
+
+def run_job(job: SupportsWait, *, wait: bool, timeout: float) -> None:
+    if not wait:
+        emit(
+            {
+                "task_id": job.task_id,
+                "task_family": job.task_family,
+                "hint": f"poll with: discolike discogen status {job.task_id} --family {job.task_family}",
+            }
+        )
+        return
+
+    def _on_poll(status: _JobStatusLike) -> None:
+        sys.stderr.write(f"progress: {status.progress}%\n")
+
+    final = job.wait(timeout=timeout, on_poll=_on_poll)
+    emit(final.results if final.results is not None else final.to_dict())

discolike_cli-0.1.0/src/discolike_cli/account.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Account usage and billing")
+
+
+@app.command("usage")
+@handle_errors
+def usage_command(ctx: typer.Context) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).account.usage())

discolike_cli-0.1.0/src/discolike_cli/auth.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import typer
+
+from discolike._config import ENV_API_KEY
+from discolike._config import KEYS_URL
+from discolike._config import delete_config
+from discolike._config import load_config
+from discolike._config import resolve_api_key
+from discolike._config import save_config
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Manage API credentials")
+
+MASKED_VISIBLE_CHARS = 4
+
+
+def _mask(key: str) -> str:
+    return "…" + key[-MASKED_VISIBLE_CHARS:]
+
+
+@app.command()
+@handle_errors
+def login(
+    api_key: str | None = typer.Option(None, help=f"API key. Create one at {KEYS_URL}"),
+) -> None:
+    from discolike_cli.main import build_client
+
+    key = api_key or typer.prompt("API key", hide_input=True)
+    build_client(api_key=key).account.usage()
+    save_config({"auth_method": "api_key", "api_key": key})
+    print(json.dumps({"logged_in": True, "source": "api_key"}), file=sys.stderr)
+
+
+@app.command()
+@handle_errors
+def status() -> None:
+    from discolike_cli.main import build_client
+
+    key = os.environ.get(ENV_API_KEY)
+    source = "env"
+    if not key:
+        key = load_config().get("api_key")
+        source = "config"
+    if not key:
+        resolve_api_key(None)
+    build_client(api_key=key).account.usage()
+    emit({"source": source, "api_key": _mask(str(key)), "valid": True})
+
+
+@app.command()
+@handle_errors
+def logout() -> None:
+    delete_config()
+    emit({"logged_out": True})

discolike_cli-0.1.0/src/discolike_cli/company.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Look up company data by domain")
+
+
+@app.command()
+@handle_errors
+def data(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.data(domain=domain))
+
+
+@app.command()
+@handle_errors
+def score(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.score(domain=domain))
+
+
+@app.command()
+@handle_errors
+def growth(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.growth(domain=domain))
+
+
+@app.command()
+@handle_errors
+def metrics(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.metrics(domain=domain))
+
+
+@app.command()
+@handle_errors
+def history(ctx: typer.Context, domain: str, max_records: int | None = typer.Option(None, "--max-records")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.history(domain=domain, max_records=max_records))
+
+
+@app.command()
+@handle_errors
+def redirects(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.redirects(domain=domain, match=match))
+
+
+@app.command()
+@handle_errors
+def vendors(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.vendors(domain=domain, match=match))
+
+
+@app.command()
+@handle_errors
+def subsidiaries(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.subsidiaries(domain=domain, match=match))
+
+
+@app.command(name="public-links")
+@handle_errors
+def public_links(ctx: typer.Context, domain: str, source: str = typer.Option(..., "--source")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.public_links(domain=domain, source=source))
+
+
+@handle_errors
+def extract_command(ctx: typer.Context, url: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.extract(url=url))