LootX

SDK Python-ի և TypeScript-ի համար

շուտով Թարմացվել է 6 նոյեմբերի, 2026 թ. Այս էջը PDF-ով

lootx (Python) և @lootx/sdk (TypeScript) հաճախորդներ — էջերի թերթում, աղյուսակներ DataFrame-ում, հոսքեր և կրկնություններ 429-ի դեպքում առանց ձեռքով կոդի։

Երկու հաճախորդներն էլ կառուցված են նույն կերպ. մեթոդ յուրաքանչյուր երթուղու համար, նույն պարամետրերի անունները, էջերի թերթում մեկ կանչով, աղյուսակները գրառումներում կամ DataFrame-ում, հոսքեր ավտոմատ վերամիացմամբ։

Տեղադրում

Python 3.10 և ավելի նոր։

Shell
pip install lootx                 # հրապարակումից հետո
pip install "lootx[pandas]"       # + to_dataframe()
pip install "lootx[protobuf]"     # + format="protobuf"

Node.js 18 և ավելի նոր կամ բրաուզեր։

Shell
npm install @lootx/sdk            # հրապարակումից հետո

Առաջին հարցում

Python
from lootx import Client

lx = Client("lx_live_...")        # կամ միջավայրի փոփոխական LOOTX_API_KEY

bars = lx.candles("binance:perp:BTCUSDT", tf="1m", from_=1793750400000, limit=500)
df = bars.to_dataframe(datetimes=True)

# բոլոր էջերը միանգամից
oi = lx.iter_oi("bybit:perp:ETHUSDT", from_=1793750400000, to=1793836800000).collect()
TypeScript
import { Client, records } from "@lootx/sdk";

const lx = new Client({ apiKey: "lx_live_..." });   // կամ LOOTX_API_KEY շրջակա միջավայրում (Node)

const bars = await lx.candles({ instrument: "binance:perp:BTCUSDT", tf: "1m", from: 1793750400000, limit: 500 });
const rows = records(bars);   // [{ ts, open, high, ... }]

const oi = await lx.iterOi({ instrument: "bybit:perp:ETHUSDT", from: 1793750400000, to: 1793836800000 }).collect();

Նույնը երկուսում էլ

Python TypeScript
Մեթոդներ snake_case, անունը = operationId սպեցիֆիկացիայի camelCase նույն անվան
Պարամետրեր ինչպես API-ում; from → from_ ինչպես API-ում, օբյեկտով
Ժամանակ Unix-մվ UTC կամ datetime Unix-մվ UTC կամ Date
Բոլոր էջերը iter_*() → collect(), rows(), to_dataframe() iter*() → collect(), rows()
Աղյուսակ records(), column(), to_dataframe() records(t), column(t, name)
Երկուական ձևաչափ Client(format="protobuf") new Client({ format: "protobuf" })
Սխալներ բացառություններ ըստ կոդի, .code, .request_id, .retry_after նույն դասերը, .code, .requestId, .retryAfter
Հոսքեր feed() — միասնական /v1/ws feed()

Հոսքեր

feed()-ը բացում է մեկ միացում /v1/ws և հիշում է բաժանորդագրությունները. ընդհատումից հետո վերամիանում է և նորից ինքնաբերաբար բաժանորդագրվում։

Python
with lx.feed() as f:
    f.subscribe("trades", ["binance:perp:BTCUSDT"])
    f.subscribe("densities", ["binance:perp:BTCUSDT", "hyperliquid:perp:BTC"])
    for msg in f:
        if msg["type"] == "update" and msg["channel"] == "trades":
            print(msg["instrument"], msg["data"]["trades"])
TypeScript
const f = lx.feed();
f.subscribe("trades", ["binance:perp:BTCUSDT"]);
f.subscribe("densities", ["binance:perp:BTCUSDT", "hyperliquid:perp:BTC"]);
for await (const m of f) {
  if (m.type === "update" && m.channel === "trades") console.log(m.instrument, m.data);
}

Ամբողջ շուկան densities կամ screener ալիքի ֆիլտրերով — subscribe_market (subscribeMarket), նույն պարամետրերը, ինչ scope: "market"-ում։ Մեկ բաժանորդագրություն ալիքի համար միացման մեջ. նորը փոխարինում է նախորդին, բացել դրանք կարելի է վայրկյանը մեկ։ Հանում է բաժանորդագրությունը unsubscribe_market-ը (unsubscribeMarket)։ Ընդհատումից հետո feed()-ը բաժանորդագրությունը նորից է ուղարկում։

Python
with lx.feed() as f:
    f.subscribe_market("densities", venues=["binance"], markets=["perp"], min_usd=250_000)
    for msg in f:
        if msg["type"] in ("snapshot", "update") and msg.get("scope") == "market":
            for item in msg["items"]:
                print(item["instrument"], item["data"])
TypeScript
const f = lx.feed();
f.subscribeMarket("densities", { venues: ["binance"], markets: ["perp"], min_usd: 250_000 });
for await (const m of f) {
  if (m.scope === "market" && m.items) for (const it of m.items) console.log(it.instrument, it.data);
}

Բաժանորդագրությունը, որը չի անցել միացման կամ վերամիացման ժամանակ, feed()-ը կրկնում է ինքը, եթե gateway-ը պատասխանել է market_subs_limit կամ rate_limited. հին տեղը gateway-ը անմիջապես չի վերադարձնում։ Կրկնություններ մինչև 3 անգամ, դադարը՝ retry_after, բայց ոչ ավելի քան 30 վ, կամ 1, 4 և 16 վ պատահական հավելումով մինչև քառորդը. սրանք վերամիացման լռելյայն կարգավորումներն են։ Մերժման կադրը կստանաք միայն վերջինը, երբ փորձերը սպառվեն։ Բաժանորդագրությունը, որը չի անցել միացման կամ վերամիացման ժամանակ, այդպիսի մերժումից հետո և ցանկացած այլից հետո, օրինակ bad_params, մնում է SDK-ում և նորից կուղարկվի հաջորդ վերամիացման ժամանակ. հանում է այն unsubscribe_market-ը (unsubscribeMarket)։ Կենդանի միացման վրա հրամանը SDK-ն չի կրկնում. մերժումը գալիս է ձեզ։ Ֆիլտրերը, որոնք մերժվել են կենդանի հրամանով, SDK-ն հետ է գլորում. վերամիացման ժամանակ կուղարկվի այն, ինչ gateway-ն ընդունել է կենդանի հրամանով կամ ինչ ուղարկվել է միացման ժամանակ և հանված չէ, իսկ եթե այդպիսին չկա, ոչինչ չի ուղարկվի։ Այդ ալիքի նոր շուկայական հրամանը (subscribe_market կամ unsubscribe_market), նոր միացումը և feed()-ի փակումը չեղարկում են սպասվող կրկնությունը։

Սխալներ և կրկնություններ

API-ի սխալը վերածվում է իր դասի բացառության — MissingKeyError, RevokedKeyError, PlanInactiveError, BadInstrumentError և այլն ըստ սխալի կոդի. 405-ի, 406-ի, 408-ի և 413-ի դեպքում՝ MethodNotAllowedError, NotAcceptableError, RequestTimeoutError և PayloadTooLargeError։ Բացառությունն ունի code, request_id (requestId) և սխալի մարմնի մանրամասներ. param, expected, limit, remaining, window, scope, retry_after (retryAfter, վայրկյաններ — մարմնից, առանց դրա Retry-After-ից), reset_at_ms (resetAtMs), history_days, earliest_allowed_ms, allow։ Դաշտերը, որոնք սերվերը չի ուղարկել, None են (undefined)։

429-ի և 503-ի դեպքում և ցանցի ընդհատման ժամանակ հաճախորդը կրկնում է հարցումը ինքը — ըստ Retry-After-ի, մինչև 3 անգամ։ Եթե սերվերը խնդրում է սպասել 30 վ-ից ավելի, սխալը տրվում է անմիջապես։ daily_quota_exceeded-ը երբեք չի կրկնվում, hourly_limit-ը և daily_limit-ը՝ միայն եթե սերվերը նշել է սպասման սահմանից ոչ ավելի դադար։

Python
from lootx import Client, RetryPolicy, errors

lx = Client("lx_live_...", retry=RetryPolicy(max_retries=5, max_wait=60))   # RetryPolicy(max_retries=0) — առանց կրկնությունների

try:
    lx.candles("binance:perp:BTCUSDT", from_=0)
except errors.HistoryOutOfPlanError as e:      # 403 history_out_of_plan
    print(e.earliest_allowed_ms, e.request_id)
except errors.RateLimitError as e:             # 429: կրկնությունները սպառվել են կամ սպասել max_wait-ից ավելի
    print(e.code, e.window, e.scope, e.retry_after)
TypeScript
const lx = new Client({ apiKey: "lx_live_...", retry: { maxRetries: 5, maxWaitMs: 60_000 } });  // { maxRetries: 0 } — առանց կրկնությունների

Սահմանաչափերը կոդից

usage()-ը — GET /v1/usage. սակագին, սահմանաչափեր, օրական ծախսը և պատուհանները հիմա։ Վերջին պատասխանի սահմանաչափերի վերնագրերը — rate_limit (rateLimit). X-RateLimit-* և վերլուծված RateLimit-Policy և RateLimit։

Python
u = lx.usage()
print(u.plan and u.plan.slug, u.limits.rpm, u.today.requests, u.today.bytes)
m = u.now.window("minute")            # limit, burst, used, remaining, reset_at_ms
print(m and m.remaining, lx.rate_limit)
TypeScript
const u = await lx.usage();
const minute = u.now.windows.find((w) => w.scope === "account" && w.window === "minute");
console.log(u.plan?.slug, minute?.remaining, lx.rateLimit);

Հոսքի error կադրը գալիս է որպես սովորական հաղորդագրություն. errors.error_from_frame(msg)-ը (errorFromFrame(frame)) այն կվերածի բացառության նույն մանրամասներով։ Փակումը 1008/1013՝ պատճառում կոդով, պահվում է հոսքի last_close_error-ում (lastCloseError) — feed()-ի դեպքում դա f.stream.last_close_error-ն է (f.stream.lastCloseError) — իր դասի բացառությամբ, օրինակ՝ SlowConsumerError slow_consumer-ի դեպքում. մուտքի մերժումը՝ revoked_key և նմանները, բացառություն է առանց վերամիացման, մնացածը՝ վերամիացում դադարով։