datalegion-cli 1.5.2__tar.gz → 1.6.0__tar.gz

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datalegion-cli
-Version: 1.5.2
+Version: 1.6.0
 Summary: CLI for the Data Legion API — agent-friendly, fully async
 Project-URL: Homepage, https://www.datalegion.ai
 Project-URL: Documentation, https://www.datalegion.ai/docs
@@ -49,6 +49,7 @@ datalegion-cli person enrich --email john@example.com
 
 - **Fully async** — async from entry point to HTTP client, powered by `asyncio` and `httpx`
 - **Agent-friendly** — all output is JSON to stdout, logs go to stderr, supports `--stdin` for piping
+- **Search warnings**: when `search` or `discover` flags one of your filters (for example an industry name no stored value matches), the API's explanation is printed on stderr as `search warning: ...`; stdout stays JSON
 - **Encrypted config** — API keys are stored encrypted at rest (Fernet + PBKDF2, machine-tied)
 - **Auto-update** — checks PyPI for a newer release and self-updates via Homebrew, GitHub release, git pull, or pip/uv
 - **Multiple install methods** — Homebrew, GitHub release, pip/uv (with private index support), or from source

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/README.md

@@ -14,6 +14,7 @@ datalegion-cli person enrich --email john@example.com
 
 - **Fully async** — async from entry point to HTTP client, powered by `asyncio` and `httpx`
 - **Agent-friendly** — all output is JSON to stdout, logs go to stderr, supports `--stdin` for piping
+- **Search warnings**: when `search` or `discover` flags one of your filters (for example an industry name no stored value matches), the API's explanation is printed on stderr as `search warning: ...`; stdout stays JSON
 - **Encrypted config** — API keys are stored encrypted at rest (Fernet + PBKDF2, machine-tied)
 - **Auto-update** — checks PyPI for a newer release and self-updates via Homebrew, GitHub release, git pull, or pip/uv
 - **Multiple install methods** — Homebrew, GitHub release, pip/uv (with private index support), or from source

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datalegion-cli"
-version = "1.5.2"
+version = "1.6.0"
 description = "CLI for the Data Legion API — agent-friendly, fully async"
 readme = "README.md"
 requires-python = ">=3.11"

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/src/datalegion_cli/client.py

@@ -58,6 +58,7 @@ class LegionClient:
         self._client: httpx.AsyncClient | None = None
         self.last_credits_used: str | None = None
         self.last_credits_remaining: str | None = None
+        self.last_search_warning: str | None = None
 
     async def _get_client(self) -> httpx.AsyncClient:
         if self._client is None or self._client.is_closed:
@@ -116,6 +117,8 @@ class LegionClient:
         # Expose credit headers
         self.last_credits_used = resp.headers.get("Credits-Used")
         self.last_credits_remaining = resp.headers.get("Credits-Remaining")
+        # search/discover: why a filter was flagged and what to change
+        self.last_search_warning = resp.headers.get("Search-Warning")
 
         return resp.json()
 

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/src/datalegion_cli/commands/company.py

@@ -10,7 +10,7 @@ import typer
 
 from datalegion_cli.async_typer import async_command
 from datalegion_cli.client import APIError, LegionClient
-from datalegion_cli.output import emit_credits, emit_error, emit_json
+from datalegion_cli.output import emit_credits, emit_error, emit_json, emit_search_warning
 
 app = typer.Typer(name="company", help="Company enrichment, search, and discovery.")
 
@@ -122,6 +122,7 @@ async def search(
         )
         emit_json(result)
         emit_credits(client.last_credits_used, client.last_credits_remaining)
+        emit_search_warning(client.last_search_warning)
     except APIError as e:
         emit_error(e.message, code=e.error, details=e.details, as_json=True)
         raise typer.Exit(1) from e
@@ -150,6 +151,7 @@ async def discover(
         )
         emit_json(result)
         emit_credits(client.last_credits_used, client.last_credits_remaining)
+        emit_search_warning(client.last_search_warning)
     except APIError as e:
         emit_error(e.message, code=e.error, details=e.details, as_json=True)
         raise typer.Exit(1) from e

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/src/datalegion_cli/commands/person.py

@@ -10,7 +10,7 @@ import typer
 
 from datalegion_cli.async_typer import async_command
 from datalegion_cli.client import APIError, LegionClient
-from datalegion_cli.output import emit_credits, emit_error, emit_json
+from datalegion_cli.output import emit_credits, emit_error, emit_json, emit_search_warning
 
 app = typer.Typer(name="person", help="Person enrichment, search, and discovery.")
 
@@ -147,6 +147,7 @@ async def search(
         )
         emit_json(result)
         emit_credits(client.last_credits_used, client.last_credits_remaining)
+        emit_search_warning(client.last_search_warning)
     except APIError as e:
         emit_error(e.message, code=e.error, details=e.details, as_json=True)
         raise typer.Exit(1) from e
@@ -175,6 +176,7 @@ async def discover(
         )
         emit_json(result)
         emit_credits(client.last_credits_used, client.last_credits_remaining)
+        emit_search_warning(client.last_search_warning)
     except APIError as e:
         emit_error(e.message, code=e.error, details=e.details, as_json=True)
         raise typer.Exit(1) from e

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/src/datalegion_cli/output.py

@@ -7,6 +7,7 @@ import sys
 from typing import Any
 
 from rich.console import Console
+from rich.markup import escape
 from rich.table import Table
 
 console = Console(stderr=True)
@@ -43,9 +44,10 @@ def emit_error(
             err["details"] = details
         print(json.dumps(err, default=str), file=sys.stdout)
     else:
-        console.print(f"[bold red]Error:[/bold red] {message}")
+        # API text is data, not markup: "[/x]" in a message raised MarkupError.
+        console.print(f"[bold red]Error:[/bold red] {escape(message)}")
         if details:
-            console.print(f"[dim]{details}[/dim]")
+            console.print(f"[dim]{escape(str(details))}[/dim]")
 
 
 def emit_success(data: Any, *, message: str | None = None, as_json: bool = True) -> None:
@@ -71,3 +73,10 @@ def emit_credits(used: str | None, remaining: str | None) -> None:
         parts.append(f"remaining: {remaining}")
     if parts:
         console.print(f"[dim]({', '.join(parts)})[/dim]")
+
+
+def emit_search_warning(warning: str | None) -> None:
+    """Show the API's Search-Warning on stderr: why a filter was flagged and what to change."""
+    if warning:
+        # One line even when stderr is not a terminal (Rich wraps at 80 columns there).
+        console.print(f"[yellow]search warning:[/yellow] {escape(warning)}", soft_wrap=True)

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/tests/test_client.py

@@ -82,6 +82,15 @@ class TestRequest:
         assert mock_client.last_credits_used == "1"
         assert mock_client.last_credits_remaining == "99"
         mock_get.assert_called_once()
+        assert mock_client.last_search_warning is None
+
+    async def test_search_warning_header_is_kept(self, mock_client, monkeypatch):
+        resp = make_response(200, {"matches": []}, {"Search-Warning": "flagged"})
+        mock_client._client = AsyncMock()
+        mock_client._client.is_closed = False
+        mock_client._client.post = AsyncMock(return_value=resp)
+        await mock_client.request("POST", "/person/search", payload={"query": "x"})
+        assert mock_client.last_search_warning == "flagged"
 
     async def test_successful_post(self, mock_client, monkeypatch):
 

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/tests/test_commands.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 from unittest.mock import patch
 
+import pytest
 from typer.testing import CliRunner
 
 from datalegion_cli.main import app
@@ -33,6 +34,7 @@ def _mock_client_request(response_json, status_code=200, headers=None):
             )
         self.last_credits_used = hdrs.get("Credits-Used")
         self.last_credits_remaining = hdrs.get("Credits-Remaining")
+        self.last_search_warning = hdrs.get("Search-Warning")
         return resp.json()
 
     return patch("datalegion_cli.client.LegionClient.request", fake_request)
@@ -466,3 +468,25 @@ class TestEnrichOffersNoMultipleResults:
         for payload in sent:
             assert "multiple_results" not in payload
             assert "limit" not in payload
+
+
+class TestSearchWarning:
+    """search and discover print the API's Search-Warning on stderr; stdout stays JSON."""
+
+    @pytest.mark.parametrize(
+        "args",
+        [
+            ["person", "search", "SELECT * FROM people WHERE company_industry = 'x'"],
+            ["person", "discover", "people in x"],
+            ["company", "search", "SELECT * FROM companies WHERE industry = 'x'"],
+            ["company", "discover", "companies in x"],
+        ],
+    )
+    def test_the_warning_reaches_stderr(self, monkeypatch, args):
+        _mock_config(monkeypatch)
+        warning = "No company_industry value matches 'x'"
+        with _mock_client_request({"matches": [], "total": 0}, headers={"Search-Warning": warning}):
+            result = runner.invoke(app, args)
+        assert result.exit_code == 0
+        assert json.loads(result.stdout) == {"matches": [], "total": 0}
+        assert f"search warning: {warning}" in result.stderr

datalegion_cli-1.6.0/tests/test_live.py

@@ -0,0 +1,107 @@
+"""Live tests: every CLI command group against the real Data Legion API.
+
+These run the commands end to end (argument parsing, the HTTP client, output) with no mocks.
+They need DATALEGION_API_KEY, the same variable the SDKs' live tests use; CI sets it, and
+without it they skip. The CLI itself reads LEGION_API_KEY, so each test passes the key on
+through that, in a temporary config directory so a developer's own login is never used.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+from typer.testing import CliRunner
+
+from datalegion_cli.main import app
+
+API_KEY = os.environ.get("DATALEGION_API_KEY", "").strip()
+
+pytestmark = pytest.mark.skipif(not API_KEY, reason="No DATALEGION_API_KEY set")
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def live_key(tmp_config_dir, monkeypatch):
+    """Use the live key and a throwaway config for every test here."""
+    monkeypatch.setenv("LEGION_API_KEY", API_KEY)
+    monkeypatch.delenv("LEGION_SANDBOX", raising=False)
+
+
+def run_json(*args: str) -> dict:
+    """Run a CLI command, require exit 0, and parse its stdout as JSON."""
+    result = runner.invoke(app, list(args))
+    assert result.exit_code == 0, f"{args} exited {result.exit_code}: {result.output}"
+    return json.loads(result.stdout)
+
+
+class TestPerson:
+    def test_search_returns_engineers_at_google(self):
+        body = run_json(
+            "person",
+            "search",
+            "SELECT * FROM people WHERE job_title ILIKE '%engineer%' "
+            "AND company_name ILIKE '%google%'",
+            "--limit",
+            "1",
+        )
+        assert isinstance(body["matches"], list)
+        assert len(body["matches"]) == 1
+        assert body["matches"][0]["person"]["legion_id"]
+
+    def test_discover_answers_a_plain_english_query(self):
+        body = run_json("person", "discover", "find software engineers at google", "--limit", "1")
+        assert len(body["matches"]) == 1
+        assert body["matches"][0]["person"]["legion_id"]
+
+    def test_sandbox_enrich_returns_the_sample_person(self):
+        body = run_json("--sandbox", "person", "enrich", "--email", "anyone@example.com")
+        assert body["matches"][0]["person"]["legion_id"] == "sandbox_person_001"
+
+
+class TestCompany:
+    def test_enrich_by_domain_finds_google(self):
+        body = run_json("company", "enrich", "--domain", "google.com")
+        company = body["matches"][0]["company"] if "matches" in body else body
+        assert company["legion_id"]
+        assert "google" in json.dumps(company.get("domain", "")).lower()
+
+    def test_search_by_domain(self):
+        body = run_json(
+            "company",
+            "search",
+            "SELECT * FROM companies WHERE domain ILIKE '%google%'",
+            "--limit",
+            "1",
+        )
+        assert len(body["matches"]) == 1
+
+    def test_discover_answers_a_plain_english_query(self):
+        body = run_json(
+            "company", "discover", "enterprise software companies with over 1000 employees",
+            "--limit", "1",
+        )  # fmt: skip
+        assert len(body["matches"]) == 1
+        assert body["matches"][0]["company"]["legion_id"]
+
+
+class TestUtility:
+    def test_clean_lowercases_and_trims_an_email(self):
+        body = run_json("utility", "clean", '{"email": "  JOHN@GMAIL.COM  "}')
+        assert body["results"]["email"]["cleaned"] == "john@gmail.com"
+
+    def test_hash_returns_all_three_digests(self):
+        body = run_json("utility", "hash", "jane.doe@gmail.com")
+        assert set(body["hashes"]) >= {"sha256", "sha1", "md5"}
+
+    def test_validate_accepts_a_real_email(self):
+        body = run_json("utility", "validate", "--email", "jane.doe@gmail.com")
+        assert body["valid"] is True
+
+
+class TestAccount:
+    def test_credits_balance_names_the_team(self):
+        body = run_json("credits", "balance")
+        assert body["team"]["team_id"]

{datalegion_cli-1.5.2 → datalegion_cli-1.6.0}/tests/test_output.py

@@ -4,7 +4,13 @@ from __future__ import annotations
 
 import json
 
-from datalegion_cli.output import emit_credits, emit_error, emit_json, emit_success
+from datalegion_cli.output import (
+    emit_credits,
+    emit_error,
+    emit_json,
+    emit_search_warning,
+    emit_success,
+)
 
 
 class TestEmitJson:
@@ -73,3 +79,26 @@ class TestEmitCredits:
         emit_credits(None, None)
         err = capsys.readouterr().err
         assert err == ""
+
+
+class TestEmitSearchWarning:
+    def test_warning_goes_to_stderr(self, capsys):
+        emit_search_warning("No company_industry value matches '[x]'")
+        captured = capsys.readouterr()
+        assert captured.out == ""
+        assert "search warning:" in captured.err and "'[x]'" in captured.err
+
+    def test_none_no_output(self, capsys):
+        emit_search_warning(None)
+        assert capsys.readouterr().err == ""
+
+
+class TestEmitErrorEscapes:
+    def test_markup_in_a_message_prints_literally(self, capsys):
+        emit_error("bad filter [/x] near [red]", details="see [b]")
+        err = capsys.readouterr().err
+        assert "[/x]" in err and "[red]" in err and "[b]" in err
+
+    def test_a_long_search_warning_stays_on_one_line(self, capsys):
+        emit_search_warning("word " * 40)
+        assert capsys.readouterr().err.count("\n") == 1