discolike-cli 0.1.1__tar.gz → 0.2.0__tar.gz

discolike_cli-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DiscoLike Inc.
+
+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.

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/PKG-INFO

@@ -1,30 +1,38 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: discolike-cli
-Version: 0.1.1
+Version: 0.2.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
+Project-URL: Changelog, https://github.com/Discolike/discolike-python/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Discolike/discolike-python/issues
 Author-email: DiscoLike <support@discolike.com>
 License-Expression: MIT
+License-File: LICENSE
 Keywords: business-data,cli,discolike,enrichment
 Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 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
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: discolike>=0.1.1
+Requires-Dist: discolike==0.2.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.
+Official CLI for the [DiscoLike API](https://discolike.com) — the `discolike` command from your terminal. Built on the [`discolike`](https://pypi.org/project/discolike/) SDK.
 
 ## Installation
 

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/README.md

@@ -1,6 +1,6 @@
 # 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.
+Official CLI for the [DiscoLike API](https://discolike.com) — the `discolike` command from your terminal. Built on the [`discolike`](https://pypi.org/project/discolike/) SDK.
 
 ## Installation
 

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/pyproject.toml

@@ -4,14 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.1.1"
+version = "0.2.0"
 description = "Official CLI for the DiscoLike API"
 readme = "README.md"
 license = "MIT"
+license-files = ["LICENSE"]
 requires-python = ">=3.10"
 authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
 dependencies = [
-  "discolike>=0.1.1",
+  "discolike==0.2.0",
   "typer>=0.12",
   "rich>=13.0",
 ]
@@ -25,6 +26,11 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Environment :: Console",
+  "Topic :: Utilities",
+  "Typing :: Typed",
 ]
 
 [project.scripts]
@@ -34,6 +40,8 @@ discolike = "discolike_cli.main:app"
 Homepage = "https://www.discolike.com"
 Documentation = "https://docs.discolike.com"
 Repository = "https://github.com/Discolike/discolike-python"
+Changelog = "https://github.com/Discolike/discolike-python/blob/main/CHANGELOG.md"
+Issues = "https://github.com/Discolike/discolike-python/issues"
 
 [tool.uv.sources]
 discolike-testkit = { workspace = true }

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/src/discolike_cli/auth.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import json
-import os
 import sys
+from typing import Any
 
 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
@@ -19,39 +18,58 @@ app = typer.Typer(help="Manage API credentials: log in, check key status, log ou
 
 MASKED_VISIBLE_CHARS = 4
 
+SOURCE_OPTION = "option"
+SOURCE_ENV = "env"
+SOURCE_CONFIG = "config"
+
 
 def _mask(key: str) -> str:
     return "…" + key[-MASKED_VISIBLE_CHARS:]
 
 
+def _global_key_source(ctx: typer.Context) -> str:
+    # typer vendors click without re-exporting ParameterSource, so match on the enum member name.
+    source = ctx.find_root().get_parameter_source("api_key")
+    return SOURCE_ENV if source is not None and source.name == "ENVIRONMENT" else SOURCE_OPTION
+
+
+def _verify(ctx: typer.Context, *, api_key: str) -> None:
+    from discolike_cli.main import build_client
+
+    kwargs: dict[str, Any] = {"api_key": api_key}
+    base_url = ctx.obj.get("base_url")
+    if base_url is not None:
+        kwargs["base_url"] = base_url
+    build_client(**kwargs).account.usage()
+
+
 @app.command()
 @handle_errors
 def login(
+    ctx: typer.Context,
     api_key: str | None = typer.Option(None, help=f"API key. Create one at {KEYS_URL}. Prompted for if omitted."),
 ) -> None:
     """Verify an API key and save it to the local config file."""
-    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()
+    # An ambient DISCOLIKE_API_KEY must not silently become the saved key; only an explicit flag may.
+    passed_globally = ctx.obj.get("api_key") if _global_key_source(ctx) == SOURCE_OPTION else None
+    key = api_key or passed_globally or typer.prompt("API key", hide_input=True)
+    _verify(ctx, api_key=key)
     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:
-    """Show which API key is in use (env or config) and verify it against the API."""
-    from discolike_cli.main import build_client
-
-    key = os.environ.get(ENV_API_KEY)
-    source = "env"
+def status(ctx: typer.Context) -> None:
+    """Show which API key is in use (option, env, or config) and verify it against the API."""
+    key = ctx.obj.get("api_key")
+    source = _global_key_source(ctx)
     if not key:
         key = load_config().get("api_key")
-        source = "config"
+        source = SOURCE_CONFIG
     if not key:
         resolve_api_key(None)
-    build_client(api_key=key).account.usage()
+    _verify(ctx, api_key=str(key))
     emit({"source": source, "api_key": _mask(str(key)), "valid": True})
 
 

discolike_cli-0.2.0/src/discolike_cli/email.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import csv
+import pathlib
+import sys
+
+import typer
+
+from discolike._email import EmailBatch
+from discolike._email import EmailBatchResults
+from discolike._email import EmailJobResult
+from discolike._exceptions import JobTimeoutError
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
+MAX_BATCH_CONTACTS = 500
+EMAIL_KINDS = ("find", "verify")
+CSV_COLUMNS = ("first_name", "last_name", "domain")
+
+FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
+WAIT_HELP = "Block until the job finishes, streaming progress to stderr."
+TIMEOUT_HELP = "Max seconds to wait with --wait."
+KIND_HELP = "Batch kind: find or verify (verify batches are created by the DiscoLike app)."
+
+app = typer.Typer(
+    help=(
+        "Find work email addresses: submit single or batch find jobs, poll them, and fetch results. "
+        "Only proven addresses bill; catch-all and pattern guesses are free."
+    )
+)
+
+
+def _job_status_to_stderr(status: EmailJobResult) -> None:
+    sys.stderr.write(f"status: {status.status}\n")
+
+
+def _batch_progress_to_stderr(results: EmailBatchResults) -> None:
+    sys.stderr.write(f"progress: {results.completed}/{results.total} completed, {results.failed} failed\n")
+
+
+def _parse_contact(value: str) -> dict[str, str]:
+    parts = [part.strip() for part in value.split(",")]
+    if len(parts) != len(CSV_COLUMNS) or not all(parts):
+        raise typer.BadParameter(f'--contact must be "first_name,last_name,domain", got {value!r}')
+    return dict(zip(CSV_COLUMNS, parts, strict=True))
+
+
+def _read_contacts_file(contacts_file: pathlib.Path) -> list[dict[str, str]]:
+    with contacts_file.open(newline="") as handle:
+        reader = csv.DictReader(handle)
+        missing = set(CSV_COLUMNS) - set(reader.fieldnames or [])
+        if missing:
+            raise typer.BadParameter(f"--contacts-file is missing required CSV columns: {', '.join(sorted(missing))}")
+        return [{column: (row.get(column) or "").strip() for column in CSV_COLUMNS} for row in reader]
+
+
+def _fetch_batch_snapshot(batch: EmailBatch) -> EmailBatchResults:
+    """Fetch the batch results once, whether or not the batch has finished."""
+    snapshot: dict[str, EmailBatchResults] = {}
+    try:
+        return batch.results(timeout=0, on_poll=lambda results: snapshot.update(latest=results))
+    except JobTimeoutError:
+        return snapshot["latest"]
+
+
+@app.command("find")
+@handle_errors
+def find_command(
+    ctx: typer.Context,
+    first_name: str = typer.Argument(..., help="First name of the person."),
+    last_name: str = typer.Argument(..., help="Last name of the person."),
+    domain: str = typer.Argument(..., help="Company domain to search, e.g. acme.com."),
+    known_pattern: str | None = typer.Option(
+        None, "--known-pattern", help="Known email local-part pattern for this domain, e.g. first.last."
+    ),
+    wait: bool = typer.Option(False, "--wait/--no-wait", help=WAIT_HELP),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Submit a single email find job (async); only a proven address bills."""
+    from discolike_cli.main import get_client
+
+    job = get_client(ctx).email.find(
+        first_name=first_name, last_name=last_name, domain=domain, known_pattern=known_pattern
+    )
+    if not wait:
+        emit({"job_id": job.job_id, "hint": f"poll with: discolike email job {job.job_id}"})
+        return
+    emit(job.wait(timeout=timeout, on_poll=_job_status_to_stderr), fmt=fmt)
+
+
+@app.command("find-batch")
+@handle_errors
+def find_batch_command(
+    ctx: typer.Context,
+    contacts_file: pathlib.Path | None = typer.Option(
+        None,
+        "--contacts-file",
+        help="Path to a CSV file with first_name,last_name,domain columns (max 500 contacts per batch).",
+    ),
+    contact: list[str] | None = typer.Option(
+        None, "--contact", help='Inline contact as "first_name,last_name,domain" (repeatable).'
+    ),
+    wait: bool = typer.Option(False, "--wait/--no-wait", help=WAIT_HELP),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Submit an email find batch from a CSV file and/or inline contacts (async)."""
+    from discolike_cli.main import get_client
+
+    contacts: list[dict[str, str]] = []
+    if contacts_file is not None:
+        contacts.extend(_read_contacts_file(contacts_file))
+    contacts.extend(_parse_contact(value) for value in contact or [])
+    if not contacts:
+        raise typer.BadParameter("provide --contacts-file and/or at least one --contact")
+    if len(contacts) > MAX_BATCH_CONTACTS:
+        raise typer.BadParameter(f"a batch holds at most {MAX_BATCH_CONTACTS} contacts, got {len(contacts)}")
+
+    batch = get_client(ctx).email.find_batch(contacts=contacts)
+    if not wait:
+        emit({"batch_id": batch.batch_id, "hint": f"fetch with: discolike email results {batch.batch_id}"})
+        return
+    emit(batch.results(timeout=timeout, on_poll=_batch_progress_to_stderr), fmt=fmt)
+
+
+@app.command("results")
+@handle_errors
+def results_command(
+    ctx: typer.Context,
+    batch_id: str = typer.Argument(..., help="Batch ID returned by `discolike email find-batch`."),
+    kind: str = typer.Option("find", "--kind", help=KIND_HELP),
+    wait: bool = typer.Option(False, "--wait/--no-wait", help=WAIT_HELP),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Fetch results for an email find or verify batch."""
+    from discolike_cli.main import get_client
+
+    if kind not in EMAIL_KINDS:
+        raise typer.BadParameter(f"--kind must be one of: {', '.join(EMAIL_KINDS)}")
+    batch = get_client(ctx).email.batch(batch_id, kind=kind)  # type: ignore[arg-type]
+    if wait:
+        emit(batch.results(timeout=timeout, on_poll=_batch_progress_to_stderr), fmt=fmt)
+        return
+    emit(_fetch_batch_snapshot(batch), fmt=fmt)
+
+
+@app.command("job")
+@handle_errors
+def job_command(
+    ctx: typer.Context,
+    job_id: str = typer.Argument(..., help="Job ID returned by `discolike email find`."),
+    wait: bool = typer.Option(False, "--wait/--no-wait", help=WAIT_HELP),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Poll a single email find job: print its current status, or block with --wait."""
+    from discolike_cli.main import get_client
+
+    job = get_client(ctx).email.job(job_id)
+    if wait:
+        emit(job.wait(timeout=timeout, on_poll=_job_status_to_stderr), fmt=fmt)
+        return
+    emit(job.status(), fmt=fmt)

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/src/discolike_cli/main.py

@@ -13,6 +13,7 @@ from discolike_cli import company
 from discolike_cli import contacts
 from discolike_cli import discogen
 from discolike_cli import discover
+from discolike_cli import email
 from discolike_cli import enrich
 from discolike_cli import match
 from discolike_cli import providers
@@ -23,7 +24,7 @@ app = typer.Typer(
     no_args_is_help=True,
     rich_markup_mode="rich",
     help=(
-        "🪩 [bold]DiscoLike[/bold] — from the entire web to your ideal target accounts.\n\n"
+        "🪩 [bold]DiscoLike[/bold] — the search engine for the business web.\n\n"
         "Discover lookalike companies, size segments, enrich domain lists, match messy "
         "company names to domains, and find the right contacts — from your terminal.\n\n"
         "Docs: https://docs.discolike.com · Keys: https://app.discolike.com/account/management/keys"
@@ -57,6 +58,7 @@ app.add_typer(auth.app, name="auth")
 app.add_typer(company.app, name="company")
 app.add_typer(contacts.app, name="contacts")
 app.add_typer(discogen.app, name="discogen")
+app.add_typer(email.app, name="email")
 app.add_typer(queries.app, name="queries")
 app.add_typer(account.app, name="account")
 app.add_typer(providers.search_providers_app, name="search-providers")

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/src/discolike_cli/queries.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
 
+import csv
+import json
+from enum import Enum
+from pathlib import Path
+
 import typer
 
 from discolike_cli._output import emit
@@ -10,6 +15,14 @@ FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls
 app = typer.Typer(help="Manage saved queries and exclusion lists for reusable targeting.")
 
 
+class SaveResultsAction(str, Enum):
+    discover = "discover"
+    segment = "segment"
+    contacts = "contacts"
+    append = "append"
+    match = "match"
+
+
 @app.command("list")
 @handle_errors
 def list_command(
@@ -48,6 +61,45 @@ def create_exclusion_list_command(
     )
 
 
+@app.command("save-results")
+@handle_errors
+def save_results_command(
+    ctx: typer.Context,
+    input_path: Path = typer.Option(
+        ..., "--input", help="Path to a .json (list of row objects) or .csv (header row) file."
+    ),
+    name: str = typer.Option(..., "--name", help="Name for the saved query."),
+    action: SaveResultsAction = typer.Option(
+        ..., "--action", help="Underlying action: discover, segment, contacts, append, or match."
+    ),
+    domain_column: str = typer.Option("domain", "--domain-column", help="Column holding domains."),
+    tag: list[str] | None = typer.Option(None, "--tag", help="Tag to attach (repeatable)."),
+) -> None:
+    """Save result rows from a file as a reusable saved query."""
+    from discolike_cli.main import get_client
+
+    try:
+        if input_path.suffix.lower() == ".csv":
+            with input_path.open(newline="") as fh:
+                data = [dict(row) for row in csv.DictReader(fh)]
+        else:
+            data = json.loads(input_path.read_text())
+    except FileNotFoundError as exc:
+        raise typer.BadParameter(f"--input file not found: {input_path}") from exc
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"--input file {input_path} must contain valid JSON: {exc}") from exc
+
+    emit(
+        get_client(ctx).queries.save_results(
+            query_name=name,
+            action=action.value,
+            data=data,
+            domain_column=domain_column,
+            tags=tag,
+        )
+    )
+
+
 @app.command("update")
 @handle_errors
 def update_command(

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/tests/conftest.py

@@ -6,24 +6,36 @@ the ``discolike-testkit`` plugin.
 """
 
 from collections.abc import Callable
+from typing import Any
 
-import httpx
+import httpx2
 import pytest
 
 import discolike_cli.main as cli_main
 from discolike import Discolike
 
-Handler = Callable[[httpx.Request], httpx.Response]
+Handler = Callable[[httpx2.Request], httpx2.Response]
+
+
+@pytest.fixture
+def build_client_calls() -> list[dict[str, Any]]:
+    """Records the keyword arguments the CLI passes to its client factory."""
+    return []
 
 
 @pytest.fixture
 def install_build_client(
     monkeypatch: pytest.MonkeyPatch,
     make_client: Callable[[Handler], Discolike],
+    build_client_calls: list[dict[str, Any]],
 ) -> Callable[[Handler], None]:
     """Point the CLI's client factory at a mock transport driven by ``handler``."""
 
     def _install(handler: Handler) -> None:
-        monkeypatch.setattr(cli_main, "build_client", lambda **kwargs: make_client(handler))
+        def _factory(**kwargs: Any) -> Discolike:
+            build_client_calls.append(kwargs)
+            return make_client(handler)
+
+        monkeypatch.setattr(cli_main, "build_client", _factory)
 
     return _install

{discolike_cli-0.1.1 → discolike_cli-0.2.0}/tests/test_account.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from collections.abc import Callable
 
-import httpx
+import httpx2
 from typer.testing import CliRunner
 
 from discolike_cli.main import app
@@ -13,9 +13,9 @@ runner = CliRunner()
 
 
 def test_account_usage_hits_usage_endpoint(install_build_client: Callable[[Handler], None]) -> None:
-    def handler(request: httpx.Request) -> httpx.Response:
+    def handler(request: httpx2.Request) -> httpx2.Response:
         assert request.url.path == "/v1/usage"
-        return httpx.Response(200, json={"requests_mtd": 100, "records_mtd": 500, "spend_mtd": 12.5})
+        return httpx2.Response(200, json={"requests_mtd": 100, "records_mtd": 500, "spend_mtd": 12.5})
 
     install_build_client(handler)
     result = runner.invoke(app, ["account", "usage"])