discovery-engine-api 0.2.62__tar.gz → 0.2.64__tar.gz

{discovery_engine_api-0.2.62 → discovery_engine_api-0.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: discovery-engine-api
-Version: 0.2.62
+Version: 0.2.64
 Summary: Python SDK for the Discovery Engine API
 Project-URL: Homepage, https://www.leap-labs.com
 Project-URL: Documentation, https://disco.leap-labs.com/llms-full.txt
@@ -25,6 +25,7 @@ Requires-Python: >=3.10
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: dev
+Requires-Dist: asyncpg>=0.27.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-timeout>=2.2.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'

{discovery_engine_api-0.2.62 → discovery_engine_api-0.2.64}/discovery/SKILL.md

@@ -27,15 +27,24 @@ This is a computational pipeline, not prompt engineering over data. You cannot r
 
 ## Getting an API Key
 
-**Programmatic (for agents):** One call to `POST /v1/signup` with an email address. Returns a `disco_` API key immediately. Free tier active on creation (10 credits/month, unlimited public runs).
+**Programmatic (for agents):** Two-step signup — send a verification code to the email, then submit it to receive the API key. The email must be real: the code is sent there and must be read to complete signup.
 
 ```bash
+# Step 1 — send verification code
 curl -X POST https://disco.leap-labs.com/v1/signup \
   -H "Content-Type: application/json" \
   -d '{"email": "agent@example.com"}'
+# → {"status": "verification_required", "email": "agent@example.com"}
+
+# Step 2 — submit code from email to get API key
+curl -X POST https://disco.leap-labs.com/v1/signup/verify \
+  -H "Content-Type: application/json" \
+  -d '{"email": "agent@example.com", "code": "123456"}'
 # → {"key": "disco_...", "key_id": "...", "organization_id": "...", "tier": "free_tier", "credits": 10}
 ```
 
+Codes expire after 15 minutes. If the email service is unavailable, `POST /v1/signup` returns the API key directly (same shape as the verify response) with no verification step required.
+
 **Manual (for humans):** Sign up at https://disco.leap-labs.com/sign-up, create key at https://disco.leap-labs.com/developers.
 
 ## Installation
@@ -54,7 +63,10 @@ from discovery import Engine
 # If you already have an API key:
 engine = Engine(api_key="disco_...")
 
-# Or sign up for one (zero-touch, no auth required):
+# Or sign up for one.
+# Sends a code to the email address and prompts for it interactively.
+# Requires a terminal — for fully automated agents, use the two-step REST API
+# in the "Getting an API Key" section above instead.
 engine = await Engine.signup(email="agent@example.com")
 
 # One-call method: submit, poll, and return results automatically
@@ -74,8 +86,8 @@ for pattern in result.patterns:
 If you need to do other work while Discovery Engine runs (recommended for agent workflows):
 
 ```python
-# Submit without waiting
-run = await engine.run_async(file="data.csv", target_column="outcome", wait=False)
+# Submit and return immediately (wait=False is the default for run_async)
+run = await engine.run_async(file="data.csv", target_column="outcome")
 print(f"Submitted run {run.run_id}, continuing with other work...")
 
 # ... do other things ...
@@ -84,7 +96,9 @@ print(f"Submitted run {run.run_id}, continuing with other work...")
 result = await engine.wait_for_completion(run.run_id, timeout=1800)
 ```
 
-This is the preferred pattern for agents. `engine.discover()` is a convenience wrapper that does this internally.
+This is the preferred pattern for agents. `engine.discover()` is a convenience wrapper that does this internally with `wait=True`.
+
+**Non-async contexts:** use `engine.discover_sync()` — same signature as `discover()`, runs in a managed event loop.
 
 ## Example Output
 
@@ -277,6 +291,93 @@ engine.discover(
 - API keys: https://disco.leap-labs.com/developers
 - Credits: https://disco.leap-labs.com/account
 
+## Paying for Credits (Programmatic)
+
+Agents can attach a payment method and purchase credits entirely via the API — no browser required.
+
+**Step 1 — Get your Stripe publishable key**
+
+```python
+account = await engine.get_account()
+stripe_pk = account["stripe_publishable_key"]
+stripe_customer_id = account["stripe_customer_id"]
+```
+
+Or via REST:
+
+```bash
+curl https://disco.leap-labs.com/v1/account \
+  -H "Authorization: Bearer disco_..."
+# → { "stripe_publishable_key": "pk_live_...", "stripe_customer_id": "cus_...", "credits": {...}, ... }
+```
+
+**Step 2 — Tokenize a card using the Stripe API**
+
+Use the publishable key to create a Stripe PaymentMethod. Card data goes directly to Stripe — Discovery Engine never sees it.
+
+```python
+import requests
+
+pm_response = requests.post(
+    "https://api.stripe.com/v1/payment_methods",
+    auth=(stripe_pk, ""),  # publishable key as username, empty password
+    data={
+        "type": "card",
+        "card[number]": "4242424242424242",
+        "card[exp_month]": "12",
+        "card[exp_year]": "2028",
+        "card[cvc]": "123",
+    },
+)
+payment_method_id = pm_response.json()["id"]  # "pm_..."
+```
+
+**Step 3 — Attach the payment method**
+
+```python
+result = await engine.add_payment_method(payment_method_id)
+# → {"payment_method_attached": True, "card_last4": "4242", "card_brand": "visa"}
+```
+
+Or via REST:
+
+```bash
+curl -X POST https://disco.leap-labs.com/v1/account/payment-method \
+  -H "Authorization: Bearer disco_..." \
+  -H "Content-Type: application/json" \
+  -d '{"payment_method_id": "pm_..."}'
+```
+
+**Step 4 — Purchase credits**
+
+Credits are sold in packs of 20 ($20/pack, $1.00/credit).
+
+```python
+result = await engine.purchase_credits(packs=1)
+# → {"purchased_credits": 20, "total_credits": 30, "charge_amount_usd": 20.0, "stripe_payment_id": "pi_..."}
+```
+
+Or via REST:
+
+```bash
+curl -X POST https://disco.leap-labs.com/v1/account/credits/purchase \
+  -H "Authorization: Bearer disco_..." \
+  -H "Content-Type: application/json" \
+  -d '{"packs": 1}'
+```
+
+**Subscriptions (optional)**
+
+For regular usage, subscribe to a paid plan instead of buying packs:
+
+```python
+# Plans: free_tier ($0, 10 cr/mo), tier_1 ($49, 50 cr/mo), tier_2 ($199, 200 cr/mo)
+result = await engine.subscribe(plan="tier_1")
+# → {"plan": "tier_1", "name": "Researcher", "monthly_credits": 50, "price_usd": 49}
+```
+
+Requires a payment method on file. See `GET /v1/plans` for full plan details.
+
 ## Estimate Before Running
 
 Before submitting a private analysis, estimate the cost and time:

{discovery_engine_api-0.2.62 → discovery_engine_api-0.2.64}/discovery/__init__.py

@@ -1,6 +1,6 @@
 """Discovery Engine Python SDK."""
 
-__version__ = "0.2.62"
+__version__ = "0.2.64"
 
 from discovery.client import Engine
 from discovery.types import (

{discovery_engine_api-0.2.62 → discovery_engine_api-0.2.64}/discovery/client.py

@@ -217,9 +217,12 @@ class Engine:
     ) -> "Engine":
         """Create an account and return a configured Engine instance.
 
-        Zero-touch signup: one call with an email address, returns a fully
-        provisioned Engine with a ``disco_`` API key. Free tier is active
-        immediately.
+        Sends a 6-digit verification code to the email address. Prompts for
+        the code interactively, then provisions the account and returns a
+        configured Engine with a ``disco_`` API key.
+
+        If the email service is unavailable, falls back to direct provisioning
+        and returns immediately (no code required).
 
         Args:
             email: Email address for the new account.
@@ -235,16 +238,40 @@ class Engine:
         body: Dict[str, Any] = {"email": email}
         if name:
             body["name"] = name
+
         async with cls._make_anon_client() as client:
             response = await client.post("/v1/signup", json=body)
             cls._raise_for_status(response)
             data = response.json()
 
-        engine = cls(api_key=data["key"], quiet=quiet)
+        # Direct provisioning fallback (Resend unavailable) — already have the key
+        if data.get("key"):
+            engine = cls(api_key=data["key"], quiet=quiet)
+            if not quiet:
+                print(
+                    f"Account created. Tier: {data.get('tier', 'free_tier')}, "
+                    f"Credits: {data.get('credits', 0)}"
+                )
+            return engine
+
+        # Verification required — prompt for the code
+        if not quiet:
+            print(f"A verification code has been sent to {data['email']}.")
+        code = input("Enter verification code: ").strip()
+
+        async with cls._make_anon_client() as client:
+            verify_response = await client.post(
+                "/v1/signup/verify",
+                json={"email": email, "code": code},
+            )
+            cls._raise_for_status(verify_response)
+            key_data = verify_response.json()
+
+        engine = cls(api_key=key_data["key"], quiet=quiet)
         if not quiet:
             print(
-                f"Account created. Tier: {data.get('tier', 'free_tier')}, "
-                f"Credits: {data.get('credits', 0)}"
+                f"Account created. Tier: {key_data.get('tier', 'free_tier')}, "
+                f"Credits: {key_data.get('credits', 0)}"
             )
         return engine
 

{discovery_engine_api-0.2.62 → discovery_engine_api-0.2.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "discovery-engine-api"
-version = "0.2.62"
+version = "0.2.64"
 description = "Python SDK for the Discovery Engine API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,7 @@ dev = [
     "pytest>=7.0.0",
     "pytest-asyncio>=0.21.0",
     "pytest-timeout>=2.2.0",
+    "asyncpg>=0.27.0",
 ]
 pandas = [
     "pandas>=2.0.0",