keelcodes 1.0.0__tar.gz

keelcodes-1.0.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: keelcodes
+Version: 1.0.0
+Summary: Keel SDK — unified access to payment / wallet / data / account modules over https://keel.codes
+Author: Keel
+License: MIT
+Project-URL: Homepage, https://keel.codes
+Keywords: keel,payment,wallet,data,account,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Keel SDK (Python)
+
+统一访问 Keel 四个模块：`payment / wallet / data / account`，基于 `https://keel.codes`。
+
+## 安装
+
+```bash
+pip install keelcodes
+```
+
+## 用法
+
+```python
+from keelcodes import Keel
+
+keel = Keel(api_key="sk_payment_xxx")
+
+# payment
+res = keel.payment.charge(
+    payer="0x...", amount_wei="1000000000000000",
+    method="x402", reference="charge_1",
+)
+print(res)
+
+# data
+bars = keel.data.bars(symbol="BTC", timeframe="1d")
+
+# account
+key = keel.account.apikey_create(tenant_id="t1", module="data")
+```
+
+## 模块
+
+- `keel.payment` — 收费/付费/查账/核验/访问
+- `keel.wallet` — 建钱包/签名/转账/链上读写/多签/会话
+- `keel.data` — 取行情/K线/因子/预测/事件/知识
+- `keel.account` — 租户/密钥/订阅
+
+## 鉴权
+
+统一 Bearer API key（按模块订阅签发 `sk_<module>_*`），传入 `Keel(api_key=...)`。

keelcodes-1.0.0/README.md

@@ -0,0 +1,41 @@
+# Keel SDK (Python)
+
+统一访问 Keel 四个模块：`payment / wallet / data / account`，基于 `https://keel.codes`。
+
+## 安装
+
+```bash
+pip install keelcodes
+```
+
+## 用法
+
+```python
+from keelcodes import Keel
+
+keel = Keel(api_key="sk_payment_xxx")
+
+# payment
+res = keel.payment.charge(
+    payer="0x...", amount_wei="1000000000000000",
+    method="x402", reference="charge_1",
+)
+print(res)
+
+# data
+bars = keel.data.bars(symbol="BTC", timeframe="1d")
+
+# account
+key = keel.account.apikey_create(tenant_id="t1", module="data")
+```
+
+## 模块
+
+- `keel.payment` — 收费/付费/查账/核验/访问
+- `keel.wallet` — 建钱包/签名/转账/链上读写/多签/会话
+- `keel.data` — 取行情/K线/因子/预测/事件/知识
+- `keel.account` — 租户/密钥/订阅
+
+## 鉴权
+
+统一 Bearer API key（按模块订阅签发 `sk_<module>_*`），传入 `Keel(api_key=...)`。

keelcodes-1.0.0/keelcodes/__init__.py

@@ -0,0 +1,24 @@
+"""Keel 聚合入口 — 4 个 namespace（payment/wallet/data/account）。"""
+
+from ._http import HttpClient
+from ._errors import KeelApiError
+from .payment import PaymentAPI
+from .wallet import WalletAPI
+from .data import DataAPI
+from .account import AccountAPI
+
+DEFAULT_BASE_URL = "https://keel.codes"
+
+
+class Keel:
+    """Keel 客户端：统一访问 4 模块。"""
+
+    def __init__(self, base_url: str = DEFAULT_BASE_URL, api_key: str = None, timeout: float = 30.0):
+        http = HttpClient(base_url=base_url, api_key=api_key, timeout=timeout)
+        self.payment = PaymentAPI(http)
+        self.wallet = WalletAPI(http)
+        self.data = DataAPI(http)
+        self.account = AccountAPI(http)
+
+
+__all__ = ["Keel", "PaymentAPI", "WalletAPI", "DataAPI", "AccountAPI", "KeelApiError"]

keelcodes-1.0.0/keelcodes/_errors.py

@@ -0,0 +1,11 @@
+"""类型化错误（对齐契约 §3 错误体）。"""
+
+
+class KeelApiError(Exception):
+    def __init__(self, path: str, status: int, code: str, body):
+        self.path = path
+        self.status = status
+        self.code = code
+        self.body = body
+        message = (body or {}).get("message", "request failed") if isinstance(body, dict) else "request failed"
+        super().__init__(f"[keelcodes] {path} {status} ({code}): {message}")

keelcodes-1.0.0/keelcodes/_http.py

@@ -0,0 +1,50 @@
+"""HTTP 客户端（零依赖，标准库 urllib；统一 Bearer key + 错误分级）。"""
+
+import json
+import urllib.request
+import urllib.error
+
+from ._errors import KeelApiError
+
+
+def _camelize(s: str) -> str:
+    head, *tail = s.split("_")
+    return head + "".join(t.capitalize() for t in tail)
+
+
+def camel_dict(d: dict) -> dict:
+    """snake_case -> camelCase，用于对齐 HTTP JSON 契约。"""
+    return {_camelize(k): v for k, v in d.items() if v is not None}
+
+
+SDK_VERSION = "1.0.0"
+
+
+class HttpClient:
+    def __init__(self, base_url: str, api_key: str = None, timeout: float = 30.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._headers = {"Content-Type": "application/json", "X-Keel-Version": SDK_VERSION}
+        if api_key:
+            self._headers["Authorization"] = f"Bearer {api_key}"
+
+    def get(self, path: str):
+        return self._request("GET", path)
+
+    def post(self, path: str, body=None):
+        return self._request("POST", path, body)
+
+    def _request(self, method: str, path: str, body=None):
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        req = urllib.request.Request(self.base_url + path, data=data, headers=self._headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                return json.loads(res.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            raw = e.read().decode("utf-8") or "{}"
+            try:
+                payload = json.loads(raw)
+            except json.JSONDecodeError:
+                payload = {}
+            code = payload.get("code", "INTERNAL") if isinstance(payload, dict) else "INTERNAL"
+            raise KeelApiError(path, e.code, code, payload)

keelcodes-1.0.0/keelcodes/account.py

@@ -0,0 +1,29 @@
+"""account 模块 — 租户/密钥/订阅（用户管自己的账户）。"""
+
+from ._http import HttpClient, camel_dict
+
+
+class AccountAPI:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def tenant_create(self, name: str, metadata: dict = None) -> dict:
+        return self._http.post("/v1/account/tenant", camel_dict({"name": name, "metadata": metadata}))
+
+    def tenant_get(self, tenant_id: str) -> dict:
+        return self._http.get(f"/v1/account/tenant/{tenant_id}")
+
+    def apikey_create(self, tenant_id: str, module: str, reference: str = None) -> dict:
+        return self._http.post("/v1/account/apikey", {"tenantId": tenant_id, "module": module, "reference": reference})
+
+    def apikey_revoke(self, api_key: str) -> dict:
+        return self._http.post("/v1/account/apikey/revoke", {"apiKey": api_key})
+
+    def subscription_get(self, module: str) -> dict:
+        return self._http.get(f"/v1/account/subscription?module={module}")
+
+    def subscription_subscribe(self, module: str, plan_id: str, reference: str = None) -> dict:
+        return self._http.post("/v1/account/subscription", {"module": module, "planId": plan_id, "reference": reference})
+
+    def subscription_cancel(self, module: str) -> dict:
+        return self._http.post("/v1/account/subscription/cancel", {"module": module})

keelcodes-1.0.0/keelcodes/data.py

@@ -0,0 +1,82 @@
+"""data 模块 — 取行情/K线/因子/预测/事件/知识。"""
+
+from ._http import HttpClient
+
+
+class DataAPI:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def bars(self, symbol: str, timeframe: str = None, market_type: str = None,
+             start: int = None, end: int = None, limit: int = None) -> dict:
+        q = f"symbol={symbol}"
+        if timeframe:
+            q += f"&timeframe={timeframe}"
+        if market_type:
+            q += f"&market_type={market_type}"
+        if start is not None:
+            q += f"&start={start}"
+        if end is not None:
+            q += f"&end={end}"
+        if limit is not None:
+            q += f"&limit={limit}"
+        return self._http.get(f"/v1/data/bars?{q}")
+
+    def tickers(self, symbols, market_type: str = None) -> dict:
+        syms = ",".join(symbols) if isinstance(symbols, (list, tuple)) else symbols
+        q = f"symbols={syms}"
+        if market_type:
+            q += f"&market_type={market_type}"
+        return self._http.get(f"/v1/data/tickers?{q}")
+
+    def factors(self, symbols: str = None, category: str = None) -> dict:
+        parts = []
+        if symbols:
+            parts.append(f"symbols={symbols}")
+        if category:
+            parts.append(f"category={category}")
+        q = "&".join(parts)
+        return self._http.get("/v1/data/factors" + (f"?{q}" if q else ""))
+
+    def graph(self, symbol: str = None, entity: str = None) -> dict:
+        parts = []
+        if symbol:
+            parts.append(f"symbol={symbol}")
+        if entity:
+            parts.append(f"entity={entity}")
+        q = "&".join(parts)
+        return self._http.get("/v1/data/graph" + (f"?{q}" if q else ""))
+
+    def predictions(self, model: str, symbol: str, start: int = None, end: int = None, limit: int = None) -> dict:
+        q = f"model={model}&symbol={symbol}"
+        if start is not None:
+            q += f"&start={start}"
+        if end is not None:
+            q += f"&end={end}"
+        if limit is not None:
+            q += f"&limit={limit}"
+        return self._http.get(f"/v1/data/predictions?{q}")
+
+    def events(self, chain: str = None, address: str = None, contract: str = None,
+               event_type: str = None, from_block: str = None, limit: int = None) -> dict:
+        parts = []
+        if chain:
+            parts.append(f"chain={chain}")
+        if address:
+            parts.append(f"address={address}")
+        if contract:
+            parts.append(f"contract={contract}")
+        if event_type:
+            parts.append(f"event_type={event_type}")
+        if from_block:
+            parts.append(f"from_block={from_block}")
+        if limit is not None:
+            parts.append(f"limit={limit}")
+        q = "&".join(parts)
+        return self._http.get("/v1/data/events" + (f"?{q}" if q else ""))
+
+    def rag(self, query: str, top_k: int = None) -> dict:
+        body = {"query": query}
+        if top_k is not None:
+            body["topK"] = top_k
+        return self._http.post("/v1/data/rag", body)

keelcodes-1.0.0/keelcodes/payment.py

@@ -0,0 +1,78 @@
+"""payment 模块 — 收费/付费/查账/核验/访问。"""
+
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Any, Dict
+
+from ._http import HttpClient, camel_dict
+
+
+@dataclass
+class ChargeParams:
+    payer: str
+    amount_wei: str
+    method: str  # fiat | x402 | a2a | batch | invite
+    reference: str
+    asset: Optional[str] = None
+    chain: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class PayParams:
+    payee: str
+    amount_wei: str
+    reference: str
+    asset: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class SettlementRecord:
+    reference: str
+    payer: str
+    amount_wei: str
+    asset: str
+    chain_id: int
+    settled_at: str
+    method: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class PaymentAPI:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def charge(self, params: ChargeParams) -> dict:
+        return self._http.post("/v1/payment/charge", camel_dict(asdict(params)))
+
+    def pay(self, params: PayParams) -> dict:
+        return self._http.post("/v1/payment/pay", camel_dict(asdict(params)))
+
+    def verify(self, tx_hash: str, chain: Optional[str] = None) -> dict:
+        return self._http.post("/v1/payment/verify", camel_dict({"tx_hash": tx_hash, "chain": chain}))
+
+    def balance(self, address: str, asset: Optional[str] = None) -> dict:
+        q = f"address={address}"
+        if asset:
+            q += f"&asset={asset}"
+        return self._http.get(f"/v1/payment/balance?{q}")
+
+    def orders(self, limit: Optional[int] = None, offset: Optional[int] = None,
+               status: Optional[str] = None, subscriber: Optional[str] = None) -> dict:
+        parts = []
+        if limit is not None:
+            parts.append(f"limit={limit}")
+        if offset is not None:
+            parts.append(f"offset={offset}")
+        if status is not None:
+            parts.append(f"status={status}")
+        if subscriber is not None:
+            parts.append(f"subscriber={subscriber}")
+        q = "&".join(parts)
+        return self._http.get("/v1/payment/orders" + (f"?{q}" if q else ""))
+
+    def settlement(self, reference: str) -> dict:
+        return self._http.get(f"/v1/payment/settlement/{reference}")
+
+    def access(self, subscriber: str, resource) -> dict:
+        return self._http.post("/v1/payment/access", {"subscriber": subscriber, "resource": resource})

keelcodes-1.0.0/keelcodes/wallet.py

@@ -0,0 +1,63 @@
+"""wallet 模块 — 建钱包/签名/转账/链上读写/多签/会话。"""
+
+from ._http import HttpClient, camel_dict
+
+
+class WalletAPI:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, type: str, chain: str = None, reference: str = None) -> dict:
+        return self._http.post("/v1/wallet/create", camel_dict({"type": type, "chain": chain, "reference": reference}))
+
+    def import_wallet(self, type: str, seed: str = None, private_key: str = None) -> dict:
+        return self._http.post("/v1/wallet/import", camel_dict({"type": type, "seed": seed, "private_key": private_key}))
+
+    def sign(self, wallet_id: str, message: str = None, typed_data: dict = None,
+             digest: str = None, chain: str = None) -> dict:
+        return self._http.post("/v1/wallet/sign", camel_dict({
+            "wallet_id": wallet_id, "message": message, "typed_data": typed_data,
+            "digest": digest, "chain": chain,
+        }))
+
+    def send(self, wallet_id: str, to: str, amount: str, chain: str, token_address: str = None,
+             reference: str = None) -> dict:
+        return self._http.post("/v1/wallet/send", camel_dict({
+            "wallet_id": wallet_id, "to": to, "amount": amount,
+            "chain": chain, "token_address": token_address, "reference": reference,
+        }))
+
+    def chain(self, chain: str, method: str, params: list = None, raw_transaction: str = None) -> dict:
+        return self._http.post("/v1/wallet/chain", camel_dict({
+            "chain": chain, "method": method, "params": params, "raw_transaction": raw_transaction,
+        }))
+
+    def balance(self, address: str, chain: str = None, token: str = None) -> dict:
+        q = f"address={address}"
+        if chain:
+            q += f"&chain={chain}"
+        if token:
+            q += f"&token={token}"
+        return self._http.get(f"/v1/wallet/balance?{q}")
+
+    def safe_propose(self, safe_address: str, to: str, value: str = None, data: str = None) -> dict:
+        return self._http.post("/v1/wallet/safe/propose", camel_dict({
+            "safe_address": safe_address, "to": to, "value": value, "data": data,
+        }))
+
+    def safe_confirm(self, safe_address: str, safe_tx_hash: str, signature: str) -> dict:
+        return self._http.post("/v1/wallet/safe/confirm", camel_dict({
+            "safe_address": safe_address, "safe_tx_hash": safe_tx_hash, "signature": signature,
+        }))
+
+    def safe_execute(self, safe_tx_hash: str) -> dict:
+        return self._http.post("/v1/wallet/safe/execute", {"safeTxHash": safe_tx_hash})
+
+    def session_create(self, **kwargs) -> dict:
+        return self._http.post("/v1/wallet/session/create", kwargs)
+
+    def session_revoke(self, session_id: str) -> dict:
+        return self._http.post("/v1/wallet/session/revoke", {"sessionId": session_id})
+
+    def session_execute(self, **kwargs) -> dict:
+        return self._http.post("/v1/wallet/session/execute", kwargs)

keelcodes-1.0.0/keelcodes.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: keelcodes
+Version: 1.0.0
+Summary: Keel SDK — unified access to payment / wallet / data / account modules over https://keel.codes
+Author: Keel
+License: MIT
+Project-URL: Homepage, https://keel.codes
+Keywords: keel,payment,wallet,data,account,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Keel SDK (Python)
+
+统一访问 Keel 四个模块：`payment / wallet / data / account`，基于 `https://keel.codes`。
+
+## 安装
+
+```bash
+pip install keelcodes
+```
+
+## 用法
+
+```python
+from keelcodes import Keel
+
+keel = Keel(api_key="sk_payment_xxx")
+
+# payment
+res = keel.payment.charge(
+    payer="0x...", amount_wei="1000000000000000",
+    method="x402", reference="charge_1",
+)
+print(res)
+
+# data
+bars = keel.data.bars(symbol="BTC", timeframe="1d")
+
+# account
+key = keel.account.apikey_create(tenant_id="t1", module="data")
+```
+
+## 模块
+
+- `keel.payment` — 收费/付费/查账/核验/访问
+- `keel.wallet` — 建钱包/签名/转账/链上读写/多签/会话
+- `keel.data` — 取行情/K线/因子/预测/事件/知识
+- `keel.account` — 租户/密钥/订阅
+
+## 鉴权
+
+统一 Bearer API key（按模块订阅签发 `sk_<module>_*`），传入 `Keel(api_key=...)`。

keelcodes-1.0.0/keelcodes.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+keelcodes/__init__.py
+keelcodes/_errors.py
+keelcodes/_http.py
+keelcodes/account.py
+keelcodes/data.py
+keelcodes/payment.py
+keelcodes/wallet.py
+keelcodes.egg-info/PKG-INFO
+keelcodes.egg-info/SOURCES.txt
+keelcodes.egg-info/dependency_links.txt
+keelcodes.egg-info/top_level.txt

keelcodes-1.0.0/keelcodes.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

keelcodes-1.0.0/keelcodes.egg-info/top_level.txt

@@ -0,0 +1 @@
+keelcodes

keelcodes-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "keelcodes"
+version = "1.0.0"
+description = "Keel SDK — unified access to payment / wallet / data / account modules over https://keel.codes"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Keel" }]
+keywords = ["keel", "payment", "wallet", "data", "account", "sdk"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://keel.codes"
+
+[tool.setuptools.packages.find]
+include = ["keelcodes*"]

keelcodes-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+