lpsignal 0.1.0__tar.gz

lpsignal-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+*.egg-info/
+build/

lpsignal-0.1.0/LICENSE

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

lpsignal-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.5
+Name: lpsignal
+Version: 0.1.0
+Summary: Official LPSignal SDK: net-of-IL APR signals for concentrated-liquidity pools, a WebSocket stream that never misses a signal, webhook verification and the REST API.
+Project-URL: Homepage, https://github.com/Ligengxin96/lpsignal-sdk
+License-Expression: MIT
+License-File: LICENSE
+Keywords: apr,concentrated-liquidity,defi,impermanent-loss,liquidity-provider,lpsignal,uniswap
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: websockets>=14
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# lpsignal (Python)
+
+Official Python SDK for [LPSignal](https://lpsignal.app): net-of-IL APR signals for concentrated-liquidity pools.
+Python ≥ 3.10, built on `httpx` and `websockets`.
+
+```bash
+pip install lpsignal
+```
+
+## REST
+
+```python
+from lpsignal import LPSignal, LPSignalError
+
+with LPSignal(api_key="lps_...") as lps:          # key optional for public endpoints
+    page = lps.pools(chain="base", window=168, min_tvl_usd=1e6)
+    top = page["pools"][0]
+    detail = lps.pool("base", top["address"])     # every (window × range) metric
+    bt = lps.backtest("base", top["address"], range_pct=5, days=7)
+    try:
+        lps.wallet_positions("0x...")
+    except LPSignalError as e:
+        if e.code == "pro_required":
+            ...
+```
+
+`AsyncLPSignal` has the same methods as coroutines. Responses are the API's JSON (camelCase keys); `lpsignal.types`
+has `TypedDict`s for the main shapes.
+
+| Method | Endpoint | Key |
+|---|---|---|
+| `health()` · `chains()` | `/v1/health` · `/v1/chains` | – |
+| `pools(chain, pair_class, window, min_tvl_usd, limit, offset)` | `GET /v1/pools` | – |
+| `pool(chain, address)` · `pool_hours(chain, address, hours)` | `GET /v1/pools/:chain/:address[/hours]` | – |
+| `backtest(chain, address, range_pct, days)` | `GET …/backtest` | – |
+| `signals(kind, limit, before)` · `signal(id)` | `GET /v1/signals[/:id]` | optional |
+| `signal_stats(days)` | `GET /v1/signals/stats` — the public track record | – |
+| `iter_signals(kind)` | every page, newest first | optional |
+| `signals_after(id)` | everything newer than `id`, oldest first | optional |
+| `smart_lps(window_days, chain, limit)` | `GET /v1/smart-lps` | optional |
+| `wallet_positions(owner)` | `GET /v1/smart-lps/:owner/positions` | Pro |
+| `follows()` · `follow(owner)` · `unfollow(owner)` | `/v1/me/follows` | Pro |
+| `me()` · `set_webhook(url)` · `delete_webhook()` · `telegram_link()` | `/v1/me…` | yes |
+| `create_api_key(replace)` | `POST /v1/me/api-key` — replaces the key (or `replace=False`: only if none), returned once | yes |
+| `billing(refresh)` · `checkout(tier)` · `billing_portal()` | `/v1/billing…` | yes |
+| `crypto_billing()` · `create_crypto_order(tier, months)` · `crypto_order(id)` · `cancel_crypto_order(id)` | `/v1/billing/crypto…` — prepaid USDT/USDC plans | yes |
+
+Errors are `LPSignalError` with `status`, `code` (the API's `error` field), `body` and `request_id`. A `429` on a
+GET, PUT or DELETE is retried after its `Retry-After` (`max_retries`, default 2).
+
+## Stream
+
+```python
+import asyncio
+from lpsignal import AsyncLPSignal, FileLastIdStore, SignalStream
+
+async def on_signal(signal, source):   # source: "rest" | "replay" | "live"
+    ...                                # once per signal, in id order, never concurrently
+
+async def main():
+    lps = AsyncLPSignal(api_key="lps_...")   # Basic or Pro
+    stream = SignalStream(lps, on_signal, store=FileLastIdStore("lpsignal-state.json"),
+                          on_event=lambda e: print(e) if e["type"] == "fatal" else None)
+    await stream.run()                        # or: await stream.start() … await stream.stop()
+
+asyncio.run(main())
+```
+
+- **First start** with an empty store: begins after the newest signal that exists now (or after `since`).
+- **Every (re)connect**: first fetches everything after the saved id over REST, repeating until a pass finds
+  nothing new, then connects with `?since=<id>`; anything at or below the saved id is dropped. No gap however long
+  you were away, and no duplicates while the process runs.
+- **Your handler decides progress**: the id is saved only after `on_signal` returns. If it raises, the connection
+  is dropped and the signal is offered again. A crash after the handler but before the save also offers it again
+  after the restart: delivery is **at-least-once**, so make the handler idempotent on `signal["id"]`.
+- **No repeats even across crashes**: keep the last id in the same database transaction as your side effects
+  (write it inside `on_signal`), and pass a `store` that reads and writes that same row; its `save()` must only
+  move forward (e.g. `UPDATE … SET last_id = GREATEST(last_id, %s)`), since the stream also saves the starting point.
+- `stop()` waits for the signal being handled; nothing new is handed over after it is called. Cancelling `run()`
+  stops the stream. Don't await `stop()` from inside `on_signal` (it would wait for itself). After a `fatal` event,
+  call `stop()` before `start()` again.
+- **Fatal** (the stream stops): invalid key (401), a plan without the stream (402), or the plan expiring (4402).
+  Everything else reconnects with backoff.
+
+The state file has the same format as the Node SDK's, so you can switch languages without losing your place.
+
+## Webhooks
+
+```python
+from fastapi import FastAPI, Request, Response
+from lpsignal import WebhookVerificationError, verify_webhook
+
+app = FastAPI()
+
+@app.post("/lpsignal")
+async def lpsignal(request: Request):
+    try:
+        event = verify_webhook(await request.body(), request.headers, SECRET)
+    except WebhookVerificationError as e:
+        return Response(e.reason, status_code=400)
+    # deliveries are at-least-once: skip event["deliveryId"] if already handled
+    return Response(status_code=200)
+```
+
+Pass the raw body bytes, never re-serialised JSON. Deliveries older than 5 minutes are rejected (`tolerance_sec`);
+every retry is signed afresh.
+
+## License
+
+MIT

lpsignal-0.1.0/README.md

@@ -0,0 +1,110 @@
+# lpsignal (Python)
+
+Official Python SDK for [LPSignal](https://lpsignal.app): net-of-IL APR signals for concentrated-liquidity pools.
+Python ≥ 3.10, built on `httpx` and `websockets`.
+
+```bash
+pip install lpsignal
+```
+
+## REST
+
+```python
+from lpsignal import LPSignal, LPSignalError
+
+with LPSignal(api_key="lps_...") as lps:          # key optional for public endpoints
+    page = lps.pools(chain="base", window=168, min_tvl_usd=1e6)
+    top = page["pools"][0]
+    detail = lps.pool("base", top["address"])     # every (window × range) metric
+    bt = lps.backtest("base", top["address"], range_pct=5, days=7)
+    try:
+        lps.wallet_positions("0x...")
+    except LPSignalError as e:
+        if e.code == "pro_required":
+            ...
+```
+
+`AsyncLPSignal` has the same methods as coroutines. Responses are the API's JSON (camelCase keys); `lpsignal.types`
+has `TypedDict`s for the main shapes.
+
+| Method | Endpoint | Key |
+|---|---|---|
+| `health()` · `chains()` | `/v1/health` · `/v1/chains` | – |
+| `pools(chain, pair_class, window, min_tvl_usd, limit, offset)` | `GET /v1/pools` | – |
+| `pool(chain, address)` · `pool_hours(chain, address, hours)` | `GET /v1/pools/:chain/:address[/hours]` | – |
+| `backtest(chain, address, range_pct, days)` | `GET …/backtest` | – |
+| `signals(kind, limit, before)` · `signal(id)` | `GET /v1/signals[/:id]` | optional |
+| `signal_stats(days)` | `GET /v1/signals/stats` — the public track record | – |
+| `iter_signals(kind)` | every page, newest first | optional |
+| `signals_after(id)` | everything newer than `id`, oldest first | optional |
+| `smart_lps(window_days, chain, limit)` | `GET /v1/smart-lps` | optional |
+| `wallet_positions(owner)` | `GET /v1/smart-lps/:owner/positions` | Pro |
+| `follows()` · `follow(owner)` · `unfollow(owner)` | `/v1/me/follows` | Pro |
+| `me()` · `set_webhook(url)` · `delete_webhook()` · `telegram_link()` | `/v1/me…` | yes |
+| `create_api_key(replace)` | `POST /v1/me/api-key` — replaces the key (or `replace=False`: only if none), returned once | yes |
+| `billing(refresh)` · `checkout(tier)` · `billing_portal()` | `/v1/billing…` | yes |
+| `crypto_billing()` · `create_crypto_order(tier, months)` · `crypto_order(id)` · `cancel_crypto_order(id)` | `/v1/billing/crypto…` — prepaid USDT/USDC plans | yes |
+
+Errors are `LPSignalError` with `status`, `code` (the API's `error` field), `body` and `request_id`. A `429` on a
+GET, PUT or DELETE is retried after its `Retry-After` (`max_retries`, default 2).
+
+## Stream
+
+```python
+import asyncio
+from lpsignal import AsyncLPSignal, FileLastIdStore, SignalStream
+
+async def on_signal(signal, source):   # source: "rest" | "replay" | "live"
+    ...                                # once per signal, in id order, never concurrently
+
+async def main():
+    lps = AsyncLPSignal(api_key="lps_...")   # Basic or Pro
+    stream = SignalStream(lps, on_signal, store=FileLastIdStore("lpsignal-state.json"),
+                          on_event=lambda e: print(e) if e["type"] == "fatal" else None)
+    await stream.run()                        # or: await stream.start() … await stream.stop()
+
+asyncio.run(main())
+```
+
+- **First start** with an empty store: begins after the newest signal that exists now (or after `since`).
+- **Every (re)connect**: first fetches everything after the saved id over REST, repeating until a pass finds
+  nothing new, then connects with `?since=<id>`; anything at or below the saved id is dropped. No gap however long
+  you were away, and no duplicates while the process runs.
+- **Your handler decides progress**: the id is saved only after `on_signal` returns. If it raises, the connection
+  is dropped and the signal is offered again. A crash after the handler but before the save also offers it again
+  after the restart: delivery is **at-least-once**, so make the handler idempotent on `signal["id"]`.
+- **No repeats even across crashes**: keep the last id in the same database transaction as your side effects
+  (write it inside `on_signal`), and pass a `store` that reads and writes that same row; its `save()` must only
+  move forward (e.g. `UPDATE … SET last_id = GREATEST(last_id, %s)`), since the stream also saves the starting point.
+- `stop()` waits for the signal being handled; nothing new is handed over after it is called. Cancelling `run()`
+  stops the stream. Don't await `stop()` from inside `on_signal` (it would wait for itself). After a `fatal` event,
+  call `stop()` before `start()` again.
+- **Fatal** (the stream stops): invalid key (401), a plan without the stream (402), or the plan expiring (4402).
+  Everything else reconnects with backoff.
+
+The state file has the same format as the Node SDK's, so you can switch languages without losing your place.
+
+## Webhooks
+
+```python
+from fastapi import FastAPI, Request, Response
+from lpsignal import WebhookVerificationError, verify_webhook
+
+app = FastAPI()
+
+@app.post("/lpsignal")
+async def lpsignal(request: Request):
+    try:
+        event = verify_webhook(await request.body(), request.headers, SECRET)
+    except WebhookVerificationError as e:
+        return Response(e.reason, status_code=400)
+    # deliveries are at-least-once: skip event["deliveryId"] if already handled
+    return Response(status_code=200)
+```
+
+Pass the raw body bytes, never re-serialised JSON. Deliveries older than 5 minutes are rejected (`tolerance_sec`);
+every retry is signed afresh.
+
+## License
+
+MIT

lpsignal-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lpsignal"
+version = "0.1.0"
+description = "Official LPSignal SDK: net-of-IL APR signals for concentrated-liquidity pools, a WebSocket stream that never misses a signal, webhook verification and the REST API."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["lpsignal", "defi", "uniswap", "concentrated-liquidity", "liquidity-provider", "impermanent-loss", "apr"]
+dependencies = ["httpx>=0.27", "websockets>=14"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-asyncio>=0.24"]
+
+[project.urls]
+Homepage = "https://github.com/Ligengxin96/lpsignal-sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lpsignal"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]

lpsignal-0.1.0/scripts/e2e.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""End-to-end check of the Python SDK against a running LPSignal API. Read-only by default (safe against production):
+
+    LPSIGNAL_BASE_URL=https://api.lpsignal.app [LPSIGNAL_API_KEY=lps_...] python scripts/e2e.py
+
+Optional:
+    E2E_WRITE=1               also exercise write endpoints (webhook, Telegram link, follows) — test/PPE accounts only
+    E2E_EXPECT_SIGNAL_SEC=60  wait this long for one live signal on the stream (something must fire meanwhile)
+    LPSIGNAL_FREE_API_KEY=... a free-plan key: the stream must refuse it
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import time
+
+from lpsignal import AsyncLPSignal, LPSignal, LPSignalError, SignalStream
+
+BASE = os.environ.get("LPSIGNAL_BASE_URL")
+if not BASE:
+    sys.exit("set LPSIGNAL_BASE_URL")
+KEY = os.environ.get("LPSIGNAL_API_KEY") or None
+FREE_KEY = os.environ.get("LPSIGNAL_FREE_API_KEY") or None
+WRITE = os.environ.get("E2E_WRITE") == "1"
+EXPECT_SIGNAL_SEC = float(os.environ.get("E2E_EXPECT_SIGNAL_SEC", "0"))
+
+anon = LPSignal(base_url=BASE)
+authed = LPSignal(base_url=BASE, api_key=KEY) if KEY else None
+reader = authed or anon
+stats = {"passed": 0, "failed": 0, "skipped": 0}
+
+
+class Skip(Exception):
+    pass
+
+
+def check(name, fn):
+    try:
+        note = fn()
+        stats["passed"] += 1
+        print(f"ok   {name}{f' — {note}' if note else ''}")
+    except Skip:
+        stats["skipped"] += 1
+        print(f"skip {name}")
+    except Exception as e:  # noqa: BLE001 - report every failure and keep going
+        stats["failed"] += 1
+        print(f"FAIL {name}: {e!r}")
+
+
+def expect(cond, msg):
+    if not cond:
+        raise AssertionError(msg)
+
+
+def expect_error(fn, status, code):
+    try:
+        fn()
+    except LPSignalError as e:
+        expect(e.status == status and e.code == code, f"got {e}")
+        return
+    raise AssertionError(f"expected {status} {code}")
+
+
+print(f"SDK E2E (python) against {BASE} ({'with key' if KEY else 'anonymous'}{', writes on' if WRITE else ', read-only'})")
+
+check("health", lambda: expect(anon.health()["ok"] is True, "not ok"))
+
+
+def chains():
+    cs = anon.chains()
+    for c in cs:
+        expect(isinstance(c["block"], str) and isinstance(c["lagSec"], int), f"bad row {c}")
+    return ", ".join(f"{c['chain']} lag {c['lagSec']}s" for c in cs) or "no chains yet"
+
+
+check("chains", chains)
+
+top: dict = {}
+
+
+def pools():
+    page = anon.pools(limit=5)
+    if not page["pools"]:  # a young deployment has no 7-day metrics yet
+        page = anon.pools(limit=5, window=24)
+    nets = [p["best"]["netApr"] for p in page["pools"]]
+    expect(len(nets) <= 5 and nets == sorted(nets, reverse=True), "not ranked/bounded")
+    if page["pools"]:
+        top.update(page["pools"][0])
+    return f"{len(nets)} pools"
+
+
+check("pools: ranked by net APR, bounded", pools)
+
+
+def detail():
+    if not top:
+        raise Skip
+    d = anon.pool(top["chain"], top["address"])
+    expect(d["pool"]["address"] == top["address"] and d["metrics"], "detail mismatch")
+    hours = anon.pool_hours(top["chain"], top["address"], hours=24)
+    expect([h["hour"] for h in hours] == sorted(h["hour"] for h in hours), "hours not ascending")
+    try:
+        bt = anon.backtest(top["chain"], top["address"], range_pct=5, days=1)
+    except LPSignalError as e:
+        if e.code in ("window_not_covered", "no_price_data"):
+            return f"backtest: {e.code}"
+        raise
+    expect(abs(bt["netApr"] - (bt["feeApr"] + bt["ilApr"])) < 1e-9 and bt["ilApr"] <= 1e-12, "APR identity")
+    return f"{len(d['metrics'])} metrics, {len(hours)} hours, backtest ok"
+
+
+check("pool detail, hours, backtest", detail)
+check("unknown pool → 404 pool_not_found", lambda: expect_error(lambda: anon.pool("base", "0x" + "0" * 40), 404, "pool_not_found"))
+check("invalid query → 400 invalid_request", lambda: expect_error(lambda: anon.pools(limit=1000), 400, "invalid_request"))
+
+newest: list = []
+
+
+def signals():
+    page = reader.signals(limit=3)
+    newest.extend(page["signals"])
+    if not newest:
+        return "no signals yet"
+    ids = [int(s["id"]) for s in newest]
+    expect(ids == sorted(ids, reverse=True), "not newest first")
+    expect(reader.signal(newest[0]["id"])["id"] == newest[0]["id"], "signal(id) mismatch")
+    seen = 0
+    for _ in reader.iter_signals(limit=2):
+        seen += 1
+        if seen >= 6:
+            break
+    if len(newest) >= 2:
+        after = reader.signals_after(newest[1]["id"])
+        expect(after and int(after[0]["id"]) > ids[1], "signals_after wrong")
+    return f"newest #{newest[0]['id']}"
+
+
+check("signals: page, by id, paging, signals_after", signals)
+def check_signal_stats():
+    st = anon.signal_stats(days=30)
+    expect(isinstance(st["scored"], int) and st["positive"] <= st["scored"] and isinstance(st["points"], list), "bad shape")
+    return f"{st['scored']} scored, {st['inexact']} inexact"
+
+
+check("signal stats (public track record)", check_signal_stats)
+check("smart LP leaderboard", lambda: expect(isinstance(reader.smart_lps(window_days=30)["wallets"], list), "bad shape"))
+
+me: dict = {}
+if authed:
+    def me_billing():
+        me.update(authed.me())
+        expect(me["tier"] == authed.billing()["tier"], "tier mismatch")
+        return f"tier {me['tier']}, paid {me['paid']}"
+
+    check("me + billing", me_billing)
+
+    def pro_gate():
+        if me.get("tier") == "pro":
+            return f"{len(authed.follows())} follows"
+        expect_error(lambda: authed.wallet_positions("0x" + "1" * 40), 403, "pro_required")
+
+    check("Pro gate", pro_gate)
+
+    async def stream_check():
+        if not me.get("paid") or len(newest) < 3:
+            raise Skip
+        got, events = [], []
+        client = AsyncLPSignal(base_url=BASE, api_key=KEY)
+        stream = SignalStream(client, lambda s, src: got.append((s["id"], src)), on_event=events.append,
+                              since=newest[2]["id"])
+        await stream.start()
+        t0 = time.monotonic()
+        while not any(e["type"] in ("live", "fatal") for e in events) and time.monotonic() - t0 < 15:
+            await asyncio.sleep(0.05)
+        live = any(e["type"] == "live" for e in events)
+        note = ""
+        if live and EXPECT_SIGNAL_SEC > 0:
+            before = len(got)
+            while not any(g[1] == "live" for g in got[before:]) and time.monotonic() - t0 < EXPECT_SIGNAL_SEC:
+                await asyncio.sleep(0.1)
+            lives = [g for g in got[before:] if g[1] == "live"]
+            expect(lives, f"no live signal within {EXPECT_SIGNAL_SEC}s")
+            note = f", live #{lives[0][0]}"
+        await stream.stop()
+        await client.aclose()
+        expect(live, f"never went live: {[e['type'] for e in events]}")
+        rest = [g[0] for g in got if g[1] == "rest"]
+        expect(newest[0]["id"] in rest and newest[1]["id"] in rest, f"catch-up missed signals: {got}")
+        ids = [int(g[0]) for g in got]
+        expect(ids == sorted(set(ids)), "not strictly ascending")
+        return f"{len(rest)} via REST{note}"
+
+    check("stream: catches up over REST from since, then goes live", lambda: asyncio.run(stream_check()))
+
+if FREE_KEY:
+    async def free_refused():
+        events = []
+        client = AsyncLPSignal(base_url=BASE, api_key=FREE_KEY)
+        s = SignalStream(client, lambda *_: None, on_event=events.append, since="0")
+        await s.start()
+        t0 = time.monotonic()
+        while not any(e["type"] == "fatal" for e in events) and time.monotonic() - t0 < 10:
+            await asyncio.sleep(0.05)
+        await s.stop()
+        await client.aclose()
+        fatal = [e for e in events if e["type"] == "fatal"]
+        expect(fatal and "402" in str(fatal[0]["error"]), f"expected 402 fatal, got {[e['type'] for e in events]}")
+        return str(fatal[0]["error"])
+
+    check("stream refuses a free key", lambda: asyncio.run(free_refused()))
+
+if authed and WRITE:
+    def webhook():
+        reg = authed.set_webhook("https://example.com/lpsignal-sdk-e2e")
+        expect(reg["secret"].startswith("whsec_"), "no secret")
+        expect(authed.me()["webhookUrl"] == reg["url"], "not stored")
+        authed.delete_webhook()
+        expect(authed.me()["webhookUrl"] is None, "not deleted")
+
+    check("write: webhook set / read back / delete", webhook)
+    check("write: webhook rejects a private address",
+          lambda: expect_error(lambda: authed.set_webhook("https://127.0.0.1/x"), 400, "invalid_webhook_url"))
+    check("write: telegram link code", lambda: expect(len(authed.telegram_link()["code"]) >= 12, "no code"))
+
+    def follows():
+        if authed.me()["tier"] != "pro":
+            raise Skip
+        owner = "0x" + "e2" * 20
+        expect(authed.follow(owner)["following"] is True, "follow")
+        expect(any(f["owner"] == owner for f in authed.follows()), "not listed")
+        authed.unfollow(owner)
+        expect(not any(f["owner"] == owner for f in authed.follows()), "still listed")
+
+    check("write: follow / unfollow (Pro)", follows)
+
+print(f"\n{stats['passed']} passed, {stats['failed']} failed, {stats['skipped']} skipped")
+sys.exit(1 if stats["failed"] else 0)

lpsignal-0.1.0/src/lpsignal/__init__.py

@@ -0,0 +1,12 @@
+"""Official LPSignal SDK: net-of-IL APR signals for concentrated-liquidity pools."""
+
+from .client import DEFAULT_BASE_URL, AsyncLPSignal, LPSignal, LPSignalError
+from .stream import FileLastIdStore, LastIdStore, MemoryLastIdStore, SignalStream
+from .webhook import WebhookVerificationError, verify_webhook
+
+__all__ = [
+    "DEFAULT_BASE_URL", "AsyncLPSignal", "LPSignal", "LPSignalError",
+    "FileLastIdStore", "LastIdStore", "MemoryLastIdStore", "SignalStream",
+    "WebhookVerificationError", "verify_webhook",
+]
+__version__ = "0.1.0"