melaya 0.1.0__tar.gz

melaya-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Build artifacts
+**/node_modules/
+**/dist/
+**/target/
+**/build/
+**/.gradle/
+**/bin/
+**/obj/
+**/vendor/
+**/__pycache__/
+*.egg-info/
+.pytest_cache/
+# Gradle/JVM
+*.class
+.gradle/
+# logs / tmp
+*.log
+*.tmp
+# IDE
+.idea/
+.vscode/
+# package locks we don't ship from staging
+**/go.sum
+**/*.exe
+
+# secrets (belt-and-suspenders)
+.env
+.env.*
+**/.env
+*.pem
+*.key
+id_rsa*

melaya-0.1.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: melaya
+Version: 0.1.0
+Summary: Official Python SDK for the Melaya unified market-data & streaming API across 70+ venues.
+Project-URL: Homepage, https://melaya.org
+Project-URL: Documentation, https://melaya.org/docs
+Project-URL: Repository, https://github.com/melaya-labs/melaya
+Project-URL: Issues, https://github.com/melaya-labs/melaya/issues
+Author: Melaya
+License-Expression: Apache-2.0
+Keywords: agentic-ai,crypto,exchange,market-data,melaya,ohlcv,orderbook,sdk,ticker,trading,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: stream
+Requires-Dist: websockets>=12; extra == 'stream'
+Description-Content-Type: text/markdown
+
+# melaya (Python SDK)
+
+Official Python SDK for the **[Melaya](https://melaya.org)** trading platform — normalized market data, paper + live trading, backtesting, and an AI agentic trading crew across **70+ venues**, powered by an in-house Rust engine.
+
+## Install
+
+```bash
+pip install melaya            # REST
+pip install "melaya[stream]"  # REST + WebSocket streaming
+```
+
+## Quick start
+
+```python
+from melaya import Melaya
+
+m = Melaya(api_key="mk_...")  # keys are prefixed `mk_`
+
+# Normalized ticker from any of 70+ venues
+t = m.market.ticker(exchange="binance", symbol="BTC/USDT", market="spot")
+print(t["last"], t["bid"], t["ask"])
+
+# Order book + candles
+book = m.market.orderbook(exchange="bybit", symbol="BTC/USDT", market="spot", limit=20)
+candles = m.market.ohlcv(exchange="okx", symbol="ETH/USDT", timeframe="1h", limit=200)
+```
+
+## Streaming (async)
+
+```python
+import asyncio
+from melaya import Melaya
+
+async def main():
+    m = Melaya(api_key="mk_...")
+    async for t in m.stream.ticker(exchange="binance", symbol="BTC/USDT", market="spot"):
+        print(t["last"])
+
+asyncio.run(main())
+```
+
+## Trading
+
+The same client covers your account, paper trading, live strategies, and backtests. Reads need only your `mk_` key; live order placement needs a connected exchange key (`m.account.keys()`).
+
+```python
+# Account
+keys = m.account.keys()            # [{"apiKeyId": "BINANCEUSDM_0", "exchange": ..., "market": ...}]
+usage = m.account.usage()
+
+# Strategies — create() launches immediately. Paper (dry_run) needs no exchange key.
+# SDK-launchable strategies are `custom` Rhai definitions (an `evaluate()` that
+# emits signals: emit_long / emit_short / emit_close).
+res = m.strategies.create(
+    name="My first bot", strategy_type="custom",
+    exchange="binanceusdm", symbol="BTC/USDT:USDT", market="FUTURES", dry_run=True,
+    params={"language": "rhai",
+            "definition": 'fn evaluate() { emit_long(param("qty")); }',
+            "qty": 0.001},   # dry_run=False + api_key_id places real orders
+)
+sid = res["strategyId"]
+m.strategies.pause(sid)
+m.strategies.resume(sid)
+trades = m.strategies.trades(sid)
+
+# Paper trading (sim broker) — synthetic fills, no venue state
+bal = m.sim.balance(strategy_id=sid)
+fill = m.sim.create_order(strategy_id=sid, exchange="binanceusdm",
+                          symbol="BTC/USDT:USDT", side="buy", type="market",
+                          amount=0.001, market="FUTURES")
+
+# Backtest on the Rust engine
+import time
+start = m.backtest.start({"strategyType": "custom", "exchange": "binance",
+                          "symbol": "BTC/USDT", "timeframe": "1h", "language": "rhai",
+                          "definition": 'fn evaluate() { emit_long(param("qty")); }',
+                          "params": {"qty": 0.001}})
+job_id = start["job_id"]
+while m.backtest.job(job_id)["status"] not in ("done", "error"):
+    time.sleep(2)
+result = m.backtest.results(job_id)   # metrics, equity_curve, ohlcv
+
+# Live private strategy feed (async; ticket minted automatically)
+async for ev in m.stream.strategies():
+    print(ev["type"], ev.get("strategyId"))
+```
+
+## Authentication
+
+Create an API key in the dashboard (**melaya.org → Settings → API Keys**). Keys are prefixed `mk_`; the SDK sends it on every REST call and WebSocket connection. Public market-data and account/strategy reads work with the key alone. **Live** order placement and live strategy launches additionally require a connected exchange key — connect one in **Settings → Connectors**, then reference it by `api_key_id`. Paper trading and backtesting never touch a venue and need no exchange credentials.
+
+## API surface
+
+| Area | Methods |
+|---|---|
+| Reference | `market.list_exchanges()`, `catalog_counts()` |
+| Market data | `market.ticker`, `orderbook`, `ohlcv`, `ohlcv_multi`, `trades`, `markets`, `currencies`, `market_constraints`, `status`, `time` |
+| Batch / derivatives | `market.tickers`, `funding_rates`, `funding_rate_history`, `funding_rate_history_multi`, `open_interest`, `open_interest_history`, `open_interest_history_multi`, `instruments`, `liquidation_events` |
+| Prediction markets | `market.prediction_markets` (polymarket, kalshi, drift_pm, sxbet, azuro, overtime) |
+| Account | `account.keys`, `usage`, `api_key_status` |
+| Strategies | `strategies.create`, `list`, `get`, `pause`, `resume`, `stop`, `delete`, `update_params`, `status`, `performance`, `executions`, `trades`, `logs` |
+| AI optimizer | `strategies.ai_opt_start`, `ai_opt_status`, `ai_opt_approve`, `ai_opt_stop`, `ai_opt_runs` |
+| Paper trading | `sim.balance`, `positions`, `open_orders`, `my_trades`, `create_order`, `cancel_order`, `list_accounts` |
+| Backtesting | `backtest.start`, `job`, `results`, `trades`, `sweep`, `list`, `favorites`, `funding_range`, `cancel`, `delete`, `delete_all` |
+| Public streaming | `stream.ticker`, `orderbook`, `ohlcv`, `trades`, `liquidations` |
+| Private streaming | `stream.strategies`, `stream.private` |
+| Live trading | `trade.balance`, `positions`, `open_orders`, `orders`, `closed_orders`, `my_trades`, `my_trades_history`, `plan_orders`, `positions_history`, `leverage`, `leverage_tiers`, `create_order`, `cancel_order`, `amend_order`, `cancel_all_orders`, `cancel_plan_orders`, `close_position`, `set_leverage`, `set_margin_mode`, `set_position_mode` |
+
+Full docs: **[melaya.org/docs](https://melaya.org/docs)**.
+
+## License
+
+[Apache-2.0](../../LICENSE)

melaya-0.1.0/README.md

@@ -0,0 +1,113 @@
+# melaya (Python SDK)
+
+Official Python SDK for the **[Melaya](https://melaya.org)** trading platform — normalized market data, paper + live trading, backtesting, and an AI agentic trading crew across **70+ venues**, powered by an in-house Rust engine.
+
+## Install
+
+```bash
+pip install melaya            # REST
+pip install "melaya[stream]"  # REST + WebSocket streaming
+```
+
+## Quick start
+
+```python
+from melaya import Melaya
+
+m = Melaya(api_key="mk_...")  # keys are prefixed `mk_`
+
+# Normalized ticker from any of 70+ venues
+t = m.market.ticker(exchange="binance", symbol="BTC/USDT", market="spot")
+print(t["last"], t["bid"], t["ask"])
+
+# Order book + candles
+book = m.market.orderbook(exchange="bybit", symbol="BTC/USDT", market="spot", limit=20)
+candles = m.market.ohlcv(exchange="okx", symbol="ETH/USDT", timeframe="1h", limit=200)
+```
+
+## Streaming (async)
+
+```python
+import asyncio
+from melaya import Melaya
+
+async def main():
+    m = Melaya(api_key="mk_...")
+    async for t in m.stream.ticker(exchange="binance", symbol="BTC/USDT", market="spot"):
+        print(t["last"])
+
+asyncio.run(main())
+```
+
+## Trading
+
+The same client covers your account, paper trading, live strategies, and backtests. Reads need only your `mk_` key; live order placement needs a connected exchange key (`m.account.keys()`).
+
+```python
+# Account
+keys = m.account.keys()            # [{"apiKeyId": "BINANCEUSDM_0", "exchange": ..., "market": ...}]
+usage = m.account.usage()
+
+# Strategies — create() launches immediately. Paper (dry_run) needs no exchange key.
+# SDK-launchable strategies are `custom` Rhai definitions (an `evaluate()` that
+# emits signals: emit_long / emit_short / emit_close).
+res = m.strategies.create(
+    name="My first bot", strategy_type="custom",
+    exchange="binanceusdm", symbol="BTC/USDT:USDT", market="FUTURES", dry_run=True,
+    params={"language": "rhai",
+            "definition": 'fn evaluate() { emit_long(param("qty")); }',
+            "qty": 0.001},   # dry_run=False + api_key_id places real orders
+)
+sid = res["strategyId"]
+m.strategies.pause(sid)
+m.strategies.resume(sid)
+trades = m.strategies.trades(sid)
+
+# Paper trading (sim broker) — synthetic fills, no venue state
+bal = m.sim.balance(strategy_id=sid)
+fill = m.sim.create_order(strategy_id=sid, exchange="binanceusdm",
+                          symbol="BTC/USDT:USDT", side="buy", type="market",
+                          amount=0.001, market="FUTURES")
+
+# Backtest on the Rust engine
+import time
+start = m.backtest.start({"strategyType": "custom", "exchange": "binance",
+                          "symbol": "BTC/USDT", "timeframe": "1h", "language": "rhai",
+                          "definition": 'fn evaluate() { emit_long(param("qty")); }',
+                          "params": {"qty": 0.001}})
+job_id = start["job_id"]
+while m.backtest.job(job_id)["status"] not in ("done", "error"):
+    time.sleep(2)
+result = m.backtest.results(job_id)   # metrics, equity_curve, ohlcv
+
+# Live private strategy feed (async; ticket minted automatically)
+async for ev in m.stream.strategies():
+    print(ev["type"], ev.get("strategyId"))
+```
+
+## Authentication
+
+Create an API key in the dashboard (**melaya.org → Settings → API Keys**). Keys are prefixed `mk_`; the SDK sends it on every REST call and WebSocket connection. Public market-data and account/strategy reads work with the key alone. **Live** order placement and live strategy launches additionally require a connected exchange key — connect one in **Settings → Connectors**, then reference it by `api_key_id`. Paper trading and backtesting never touch a venue and need no exchange credentials.
+
+## API surface
+
+| Area | Methods |
+|---|---|
+| Reference | `market.list_exchanges()`, `catalog_counts()` |
+| Market data | `market.ticker`, `orderbook`, `ohlcv`, `ohlcv_multi`, `trades`, `markets`, `currencies`, `market_constraints`, `status`, `time` |
+| Batch / derivatives | `market.tickers`, `funding_rates`, `funding_rate_history`, `funding_rate_history_multi`, `open_interest`, `open_interest_history`, `open_interest_history_multi`, `instruments`, `liquidation_events` |
+| Prediction markets | `market.prediction_markets` (polymarket, kalshi, drift_pm, sxbet, azuro, overtime) |
+| Account | `account.keys`, `usage`, `api_key_status` |
+| Strategies | `strategies.create`, `list`, `get`, `pause`, `resume`, `stop`, `delete`, `update_params`, `status`, `performance`, `executions`, `trades`, `logs` |
+| AI optimizer | `strategies.ai_opt_start`, `ai_opt_status`, `ai_opt_approve`, `ai_opt_stop`, `ai_opt_runs` |
+| Paper trading | `sim.balance`, `positions`, `open_orders`, `my_trades`, `create_order`, `cancel_order`, `list_accounts` |
+| Backtesting | `backtest.start`, `job`, `results`, `trades`, `sweep`, `list`, `favorites`, `funding_range`, `cancel`, `delete`, `delete_all` |
+| Public streaming | `stream.ticker`, `orderbook`, `ohlcv`, `trades`, `liquidations` |
+| Private streaming | `stream.strategies`, `stream.private` |
+| Live trading | `trade.balance`, `positions`, `open_orders`, `orders`, `closed_orders`, `my_trades`, `my_trades_history`, `plan_orders`, `positions_history`, `leverage`, `leverage_tiers`, `create_order`, `cancel_order`, `amend_order`, `cancel_all_orders`, `cancel_plan_orders`, `close_position`, `set_leverage`, `set_margin_mode`, `set_position_mode` |
+
+Full docs: **[melaya.org/docs](https://melaya.org/docs)**.
+
+## License
+
+[Apache-2.0](../../LICENSE)

melaya-0.1.0/e2e/smoke.py

@@ -0,0 +1,270 @@
+"""FULL endpoint validation for the `melaya` Python SDK — every method, live.
+Safety: paper/sim only. NEVER places a live order or launches a live strategy.
+Destructive/billable endpoints (backtest.delete_all, strategies.ai_opt_start /
+ai_opt_approve) are WIRED-checked, not invoked.
+Run: MK=mk_... python smoke.py   (SDK src on sys.path)
+"""
+import asyncio
+import os
+import sys
+import time
+
+import os as _os; sys.path.insert(0, _os.path.join(_os.path.dirname(__file__), "..", "src"))
+from melaya import Melaya, MelayaError  # noqa: E402
+
+KEY = os.environ.get("MK")
+if not KEY:
+    print("set MK=mk_..."); sys.exit(2)
+m = Melaya(api_key=KEY)
+# Local dev box does TLS interception; disable cert verification for the test
+# (mirrors NODE_TLS_REJECT_UNAUTHORIZED=0 used by the Node smoke). Not an SDK concern.
+import warnings as _w  # noqa: E402
+import httpx as _httpx  # noqa: E402
+_w.filterwarnings("ignore")
+m._http = _httpx.Client(base_url="https://api.melaya.org", timeout=30.0,
+                        headers={"Authorization": f"Bearer {KEY}"}, verify=False)
+import ssl as _ssl  # noqa: E402
+_NOVERIFY = _ssl.create_default_context()
+_NOVERIFY.check_hostname = False
+_NOVERIFY.verify_mode = _ssl.CERT_NONE
+SPOT = dict(exchange="binance", symbol="BTC/USDT", market="spot")
+PERP = dict(exchange="binanceusdm", symbol="BTC/USDT:USDT")
+R = []
+
+
+def rec(cat, name, st, d=""):
+    R.append((cat, name, st, str(d)[:80]))
+
+
+def chk(cat, name, fn, validate=None, retry=False):
+    for i in range(2 if retry else 1):
+        try:
+            r = fn()
+            if validate is None or validate(r):
+                rec(cat, name, "PASS", _short(r)); return r
+            if i == (1 if retry else 0):
+                rec(cat, name, "FAIL", "invalid shape: " + _short(r)); return r
+        except MelayaError as e:
+            if i == (1 if retry else 0):
+                rec(cat, name, "FAIL", f"{e.status or ''} {e.code or ''} {str(e)[:70]}"); return None
+        except Exception as e:  # noqa: BLE001
+            if i == (1 if retry else 0):
+                rec(cat, name, "FAIL", str(e)[:80]); return None
+        time.sleep(1.6)
+
+
+def _short(r):
+    import json
+    try:
+        return json.dumps(r)[:80]
+    except Exception:  # noqa: BLE001
+        return str(r)[:80]
+
+
+def is_list(n=0):
+    return lambda r: isinstance(r, list) and len(r) >= n
+
+
+def is_obj(r):
+    return isinstance(r, dict) and len(r) > 0
+
+
+# ════ MARKET (22) ════
+chk("market", "list_exchanges", lambda: m.market.list_exchanges(), is_list(60))
+chk("market", "ticker", lambda: m.market.ticker(**SPOT), lambda r: is_obj(r) and (r.get("last") is not None or r.get("bid") is not None), retry=True)
+chk("market", "orderbook", lambda: m.market.orderbook(**SPOT, limit=5), lambda r: r.get("bids"), retry=True)
+chk("market", "ohlcv", lambda: m.market.ohlcv(**SPOT, timeframe="1h", limit=10), is_list(1), retry=True)
+chk("market", "trades", lambda: m.market.trades(**SPOT), is_list(1), retry=True)
+chk("market", "markets", lambda: m.market.markets(exchange="binance"), is_list(1))
+chk("market", "currencies", lambda: m.market.currencies(exchange="kraken"), is_list(1), retry=True)
+chk("market", "status", lambda: m.market.status(exchange="binance"), is_obj)
+chk("market", "time", lambda: m.market.time(exchange="binance"), lambda r: r is not None)
+chk("market", "tickers", lambda: m.market.tickers(exchange="binance", symbols=["BTC/USDT", "ETH/USDT"]), is_obj, retry=True)
+chk("market", "funding_rates", lambda: m.market.funding_rates(exchange="binanceusdm", symbols=[PERP["symbol"]]), is_obj, retry=True)
+chk("market", "funding_rate_history", lambda: m.market.funding_rate_history(exchange="binanceusdm", symbol=PERP["symbol"], hours=24), is_list(1), retry=True)
+chk("market", "open_interest", lambda: m.market.open_interest(exchange="binanceusdm", symbols=[PERP["symbol"]]), is_obj, retry=True)
+chk("market", "open_interest_history", lambda: m.market.open_interest_history(exchange="binanceusdm", symbol=PERP["symbol"], hours=24), is_list(1), retry=True)
+chk("market", "instruments", lambda: m.market.instruments(exchange="binanceusdm"), is_obj)
+chk("market", "liquidation_events", lambda: m.market.liquidation_events(exchange="binanceusdm", limit=10), lambda r: isinstance(r, list))
+chk("market", "ohlcv_multi", lambda: m.market.ohlcv_multi(exchange="binance", symbols=["BTC/USDT", "ETH/USDT"], timeframe="1h", limit=5, market="spot"), is_obj, retry=True)
+chk("market", "market_constraints", lambda: m.market.market_constraints(exchange="binanceusdm", symbol=PERP["symbol"]), lambda r: r is not None)
+chk("market", "funding_rate_history_multi", lambda: m.market.funding_rate_history_multi(exchanges=["binanceusdm", "bybitlinear"], symbol=PERP["symbol"], hours=24), is_obj, retry=True)
+chk("market", "open_interest_history_multi", lambda: m.market.open_interest_history_multi(exchanges=["binanceusdm", "bybitlinear"], symbol=PERP["symbol"], hours=24), is_obj, retry=True)
+chk("market", "prediction_markets", lambda: m.market.prediction_markets(venue="polymarket"), is_list(1), retry=True)
+chk("market", "catalog_counts", lambda: m.market.catalog_counts(), lambda r: r.get("tools", 0) > 0)
+
+# ════ ACCOUNT (3) ════
+chk("account", "keys", lambda: m.account.keys(), lambda r: isinstance(r, list))
+chk("account", "usage", lambda: m.account.usage(), lambda r: r.get("tier") is not None)
+chk("account", "api_key_status", lambda: m.account.api_key_status(), is_obj)
+
+# ════ STRATEGIES — reads on an existing one; lifecycle on a fresh custom paper one ════
+lst = chk("strategies", "list", lambda: m.strategies.list(), is_list(1))
+read_sid = lst[0]["strategyId"] if lst else None
+if read_sid:
+    chk("strategies", "get", lambda: m.strategies.get(read_sid), lambda r: r.get("strategyId") == read_sid)
+    chk("strategies", "status", lambda: m.strategies.status(read_sid), is_obj)
+    chk("strategies", "executions", lambda: m.strategies.executions(read_sid), lambda r: isinstance(r, list))
+    chk("strategies", "trades", lambda: m.strategies.trades(read_sid), lambda r: isinstance(r, list))
+    chk("strategies", "performance", lambda: m.strategies.performance(read_sid), lambda r: isinstance(r, list))
+    chk("strategies", "logs", lambda: m.strategies.logs(read_sid), lambda r: isinstance(r, list))
+    chk("strategies", "ai_opt_status", lambda: m.strategies.ai_opt_status(read_sid), is_obj)
+    chk("strategies", "ai_opt_runs", lambda: m.strategies.ai_opt_runs(read_sid), lambda r: r is not None)
+
+RHAI = 'fn evaluate() {\n    let qty = param("qty");\n    if qty == () { qty = 0.001; }\n    emit_long(qty);\n}'
+created = chk("strategies", "create(custom,paper)", lambda: m.strategies.create(
+    name="SDK full-smoke py (custom)", strategy_type="custom",
+    exchange="binanceusdm", symbol="BTC/USDT:USDT", market="FUTURES", dry_run=True,
+    params={"language": "rhai", "definition": RHAI, "qty": 0.001},
+), lambda r: r.get("ok") and r.get("strategyId"))
+paper_sid = created.get("strategyId") if created else None
+
+if paper_sid:
+    chk("strategies", "pause", lambda: m.strategies.pause(paper_sid), lambda r: r.get("ok"))
+    chk("strategies", "resume", lambda: m.strategies.resume(paper_sid), lambda r: r.get("ok"))
+    chk("strategies", "update_params", lambda: m.strategies.update_params(paper_sid, {"qty": 0.002}), lambda r: r.get("ok"))
+    chk("strategies", "ai_opt_stop", lambda: m.strategies.ai_opt_stop(paper_sid), lambda r: r.get("ok"))
+
+    # ════ SIM (7) ════
+    chk("sim", "balance", lambda: m.sim.balance(strategy_id=paper_sid), lambda r: r.get("total") is not None)
+    chk("sim", "positions", lambda: m.sim.positions(strategy_id=paper_sid), lambda r: isinstance(r, list))
+    chk("sim", "list_accounts", lambda: m.sim.list_accounts(), lambda r: isinstance(r, list))
+    chk("sim", "my_trades", lambda: m.sim.my_trades(strategy_id=paper_sid), lambda r: isinstance(r, list))
+    px = 60000
+    try:
+        t = m.market.ticker(**PERP); px = float(t.get("last") or t.get("bid") or 60000)
+    except Exception:  # noqa: BLE001
+        pass
+    ordr = chk("sim", "create_order(limit,resting)", lambda: m.sim.create_order(
+        strategy_id=paper_sid, exchange="binanceusdm", symbol="BTC/USDT:USDT",
+        side="buy", type="limit", price=round(px * 0.5), amount=0.001, market="FUTURES",
+    ), lambda r: r.get("order_id"))
+    chk("sim", "open_orders", lambda: m.sim.open_orders(strategy_id=paper_sid), lambda r: isinstance(r, list))
+    if ordr and ordr.get("order_id"):
+        oid = ordr["order_id"]
+        chk("sim", "cancel_order", lambda: m.sim.cancel_order(strategy_id=paper_sid, order_id=oid, symbol="BTC/USDT:USDT", exchange="binanceusdm"), is_obj)
+    else:
+        rec("sim", "cancel_order", "SKIP", "no resting order id")
+else:
+    for n in ["pause", "resume", "update_params", "ai_opt_stop"]:
+        rec("strategies", n, "SKIP", "create failed")
+    for n in ["balance", "positions", "list_accounts", "my_trades", "create_order(limit,resting)", "open_orders", "cancel_order"]:
+        rec("sim", n, "SKIP", "no paper sid")
+
+rec("strategies", "ai_opt_start", "WIRED", "not invoked (billed optimization)")
+rec("strategies", "ai_opt_approve", "WIRED", "not invoked (applies optimizer output)")
+
+# ════ BACKTEST (custom strategy, end-to-end; deleteAll skipped) ════
+now = int(time.time() * 1000)
+bt = chk("backtest", "start(custom)", lambda: m.backtest.start({
+    "strategyType": "custom", "exchange": "binance", "symbol": "BTC/USDT", "timeframe": "1h",
+    "since_ms": now - 60 * 86400000, "until_ms": now, "initial_equity": 10000,
+    "language": "rhai", "definition": RHAI, "custom_code": RHAI, "params": {"qty": 0.001},
+}), lambda r: r.get("job_id"))
+job_id = bt.get("job_id") if bt else None
+if job_id:
+    status = "pending"
+    for _ in range(20):
+        if status in ("done", "error", "halted", "cancelled"):
+            break
+        time.sleep(2)
+        try:
+            status = str(m.backtest.job(job_id).get("status", "")).lower()
+        except Exception:  # noqa: BLE001
+            pass
+    chk("backtest", "job(poll)", lambda: m.backtest.job(job_id), lambda r: r.get("job_id") == job_id)
+    if status == "done":
+        chk("backtest", "results", lambda: m.backtest.results(job_id), is_obj)
+        chk("backtest", "trades", lambda: m.backtest.trades(job_id, limit=10), lambda r: isinstance(r, list))
+    else:
+        rec("backtest", "results", "SKIP", f"job {status}")
+        rec("backtest", "trades", "SKIP", f"job {status}")
+chk("backtest", "list", lambda: m.backtest.list(limit=5), lambda r: isinstance(r, list))
+chk("backtest", "favorites", lambda: m.backtest.favorites(limit=5), lambda r: isinstance(r, list))
+chk("backtest", "funding_range", lambda: m.backtest.funding_range(exchange="binanceusdm", symbol=PERP["symbol"]), lambda r: r is None or isinstance(r, (int, float)))
+sweep = chk("backtest", "start(grid_sweep)", lambda: m.backtest.start({
+    "mode": "grid_sweep", "strategyType": "custom", "exchange": "binance", "symbol": "BTC/USDT", "timeframe": "1h",
+    "since_ms": now - 30 * 86400000, "until_ms": now, "language": "rhai", "definition": RHAI, "custom_code": RHAI,
+    "paramRanges": {"qty": [0.001, 0.002]},
+}), lambda r: r.get("job_id"))
+if sweep and sweep.get("job_id"):
+    chk("backtest", "sweep", lambda: m.backtest.sweep(sweep["job_id"], limit=10), is_obj)
+else:
+    rec("backtest", "sweep", "SKIP", "no sweep parent")
+cj = chk("backtest", "start(for-cancel)", lambda: m.backtest.start({
+    "strategyType": "custom", "exchange": "binance", "symbol": "ETH/USDT", "timeframe": "1h",
+    "since_ms": now - 365 * 86400000, "until_ms": now, "language": "rhai", "definition": RHAI, "custom_code": RHAI, "params": {"qty": 0.001},
+}), lambda r: r.get("job_id"))
+if cj and cj.get("job_id"):
+    chk("backtest", "cancel", lambda: m.backtest.cancel(cj["job_id"]), is_obj)
+    chk("backtest", "delete", lambda: m.backtest.delete(cj["job_id"]), lambda r: r.get("ok"))
+else:
+    rec("backtest", "cancel", "SKIP", "no job"); rec("backtest", "delete", "SKIP", "no job")
+rec("backtest", "delete_all", "WIRED", "not invoked (soft-deletes ALL non-favorited jobs)")
+
+
+# ════ STREAMS — public (5) + private (2) ════
+async def stream_chk(cat, name, factory):
+    opened = False
+    try:
+        agen = factory().__aiter__()
+        frame = await asyncio.wait_for(agen.__anext__(), timeout=10)
+        rec(cat, name, "PASS", "frame " + _short(frame)[:45])
+    except asyncio.TimeoutError:
+        rec(cat, name, "PASS" if opened else "FAIL", "no frame in 10s")
+    except Exception as e:  # noqa: BLE001
+        rec(cat, name, "FAIL", str(e)[:60])
+
+
+async def run_streams():
+    await stream_chk("stream", "ticker", lambda: m.stream.ticker(**SPOT))
+    await stream_chk("stream", "orderbook", lambda: m.stream.orderbook(**SPOT, limit=10))
+    await stream_chk("stream", "ohlcv", lambda: m.stream.ohlcv(**SPOT, timeframe="1m"))
+    await stream_chk("stream", "trades", lambda: m.stream.trades(**SPOT))
+    await stream_chk("stream", "liquidations", lambda: m.stream.liquidations(exchange="binanceusdm"))
+    await stream_chk("stream", "strategies(private)", lambda: m.stream.strategies())
+    try:
+        keys = m.account.keys()
+    except Exception:  # noqa: BLE001
+        keys = []
+    if keys:
+        k = keys[0]
+        await stream_chk("stream", "private(account)", lambda: m.stream.private(exchange=k.get("exchange"), market=k.get("market"), api_key_id=k.get("apiKeyId")))
+    else:
+        rec("stream", "private(account)", "SKIP", "no connected key")
+
+asyncio.run(run_streams())
+
+# ════ TRADE — live credentialed reads (5); write ops WIRED — real funds ════
+_VEN = dict(exchange="bitgetfutures", api_key_id="BITGETFUTURES_0", market_type="futures")
+chk("trade", "balance", lambda: m.trade.balance(**_VEN), lambda r: r.get("ok") is True)
+chk("trade", "positions", lambda: m.trade.positions(**_VEN), lambda r: r.get("ok") is True)
+chk("trade", "open_orders", lambda: m.trade.open_orders(**_VEN), lambda r: r.get("ok") is True)
+chk("trade", "orders", lambda: m.trade.orders(**_VEN), lambda r: r.get("ok") is True)
+chk("trade", "my_trades", lambda: m.trade.my_trades(**_VEN, symbol="BTC/USDT:USDT"), lambda r: r.get("ok") is True)
+for _w in ["create_order","cancel_order","amend_order","cancel_all_orders","cancel_plan_orders","close_position","set_leverage","set_margin_mode","set_position_mode"]:
+    rec("trade", _w, "WIRED", "not invoked — LIVE write, real funds")
+
+# ════ TEARDOWN ════
+if paper_sid:
+    chk("teardown", "strategies.stop", lambda: m.strategies.stop(paper_sid), lambda r: r.get("ok"))
+    chk("teardown", "strategies.delete", lambda: m.strategies.delete(paper_sid), lambda r: r.get("ok"))
+
+m.close()
+
+# ════ REPORT ════
+print("\n============== MELAYA SDK — FULL ENDPOINT VALIDATION (Python) ==============")
+cats = []
+for c, *_ in R:
+    if c not in cats:
+        cats.append(c)
+nP = nF = nW = nS = 0
+for cat in cats:
+    print(f"\n-- {cat} --")
+    for c, name, st, d in [x for x in R if x[0] == cat]:
+        print(f"  {st:<5} {name:<28} {d}")
+        nP += st == "PASS"; nF += st == "FAIL"; nW += st == "WIRED"; nS += st == "SKIP"
+print("\n===========================================================================")
+print(f"PASS {nP}   FAIL {nF}   WIRED(not-invoked) {nW}   SKIP {nS}   |  total {nP + nF + nW + nS}")
+print("RESULT: GO — every invoked endpoint validated." if nF == 0 else f"RESULT: NO-GO — {nF} failing.")
+sys.exit(0 if nF == 0 else 1)

melaya-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "melaya"
+version = "0.1.0"
+description = "Official Python SDK for the Melaya unified market-data & streaming API across 70+ venues."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "Melaya" }]
+keywords = [
+    "melaya",
+    "trading",
+    "crypto",
+    "market-data",
+    "exchange",
+    "websocket",
+    "orderbook",
+    "ohlcv",
+    "ticker",
+    "agentic-ai",
+    "sdk",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+stream = ["websockets>=12"]
+
+[project.urls]
+Homepage = "https://melaya.org"
+Documentation = "https://melaya.org/docs"
+Repository = "https://github.com/melaya-labs/melaya"
+Issues = "https://github.com/melaya-labs/melaya/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/melaya"]

melaya-0.1.0/src/melaya/__init__.py

@@ -0,0 +1,13 @@
+"""Official Python SDK for the Melaya unified market-data & streaming API.
+
+>>> from melaya import Melaya
+>>> m = Melaya(api_key="mk_...")
+>>> m.market.ticker(exchange="binance", symbol="BTC/USDT", market="spot")
+
+See https://melaya.org/docs
+"""
+from .client import Melaya, DEFAULT_BASE_URL, DEFAULT_WS_URL
+from .errors import MelayaError
+
+__all__ = ["Melaya", "MelayaError", "DEFAULT_BASE_URL", "DEFAULT_WS_URL"]
+__version__ = "0.1.0"

melaya-0.1.0/src/melaya/account.py

@@ -0,0 +1,27 @@
+"""Account API — authenticated reads about your Melaya account.
+
+Connected-exchange key references (masked), tier limits, and live usage
+counters. Requires an ``mk_`` key on the private plane.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List
+
+_Request = Callable[..., Any]
+
+
+class AccountAPI:
+    def __init__(self, request: _Request) -> None:
+        self._request = request
+
+    def keys(self) -> List[Dict[str, Any]]:
+        """Connected exchange keys. ``apiKey`` is masked; use ``apiKeyId`` as the reference."""
+        return self._request("GET", "/api/v1/private/keys")["keys"]
+
+    def usage(self) -> Dict[str, Any]:
+        """Tier, plan limits, and live usage counters."""
+        return self._request("GET", "/api/v1/private/usage")
+
+    def api_key_status(self) -> Dict[str, Any]:
+        """Status of your platform API key (tier, max concurrent connections)."""
+        return self._request("GET", "/api/v1/private/api-key")