# Python SDK (clore-ai)

द **clore-ai** पैकेज आधिकारिक पायथन SDK है [Clore.ai](https://clore.ai) GPU मार्केटप्लेस के लिए। यह पूरे REST API को एक साफ़, प्रकार-सुरक्षित इंटरफ़ेस में लपेटता है जिसमें अंतर्निर्मित दर-सीमा, स्वचालित पुन:प्रयास, और संरचित त्रुटि हैंडलिंग शामिल हैं — ताकि आप GPU किराए पर लेने पर ध्यान दे सकें, HTTP पाइपलाइनिंग पर नहीं।

***

## इंस्टॉलेशन

```bash
pip install clore-ai
```

**आवश्यकताएँ:** Python 3.9+

पैकेज दोनों इंस्टॉल करता है: पायथन SDK और [`clore` CLI](/clore.ai/clore.ai-eng-hi/developers/cli-guide.md).

***

## प्रमाणीकरण

अपनी API कुंजी प्राप्त करें [Clore.ai डैशबोर्ड](https://clore.ai) → **API** अनुभाग।

### विकल्प 1: एन्वायरनमेंट वेरिएबल (अनुशंसित)

```bash
export CLORE_API_KEY=your_api_key_here
```

SDK पढ़ता है `CLORE_API_KEY` स्वचालित रूप से — किसी कोड परिवर्तन की आवश्यकता नहीं।

### विकल्प 2: CLI कॉन्फिग फ़ाइल

```bash
clore config set api_key YOUR_API_KEY
```

यह कुंजी में संग्रहीत करता है `~/.clore/config.json`.

### विकल्प 3: कोड में सीधे पास करें

```python
from clore_ai import CloreAI

client = CloreAI(api_key="your_api_key_here")
```

> ⚠️ **महत्वपूर्ण:** Clore.ai API प्रमाणीकरण के लिए उपयोग करता है `auth` हेडर, **नहीं** `Authorization: Bearer`। SDK इसे स्वचालित रूप से संभालता है।

***

## त्वरित आरंभ

```python
from clore_ai import CloreAI

client = CloreAI()
servers = client.marketplace(gpu="RTX 4090", max_price_usd=5.0)
for s in servers:
    print(f"Server {s.id}: {s.gpu_model} — ${s.price_usd:.4f}/h")
```

***

## सिंक क्लाइंट (`CloreAI`)

### कन्स्ट्रक्टर

```python
CloreAI(
    api_key: str | None = None,       # CLORE_API_KEY env / config पर वापसFallback
    base_url: str | None = None,       # डिफ़ॉल्ट: https://api.clore.ai/v1
    timeout: float = 30.0,             # अनुरोध टाइमआउट सेकंड में
    max_retries: int = 3               # दर-सीमा / नेटवर्क त्रुटियों पर पुन:प्रयास प्रयास
)
```

क्लाइंट स्वचालित क्लीनअप के लिए कॉन्टेक्स्ट मैनेजर का समर्थन करता है:

```python
with CloreAI() as client:
    wallets = client.wallets()
    # client.close() स्वचालित रूप से कॉल किया गया
```

***

### `wallets()`

अपनी वॉलेट शेष और जमा पते प्राप्त करें।

```python
wallets = client.wallets()

for wallet in wallets:
    print(f"{wallet.name}: {wallet.balance:.8f}")
    if wallet.deposit:
        print(f"  Deposit: {wallet.deposit}")
```

**परिणाम:** `List[Wallet]`

| फ़ील्ड           | प्रकार          | वर्णन                                                                      |
| ---------------- | --------------- | -------------------------------------------------------------------------- |
| `name`           | `str`           | मुद्रा का नाम (उदा. `"bitcoin"`, `"CLORE-Blockchain"`, `"USD-Blockchain"`) |
| `balance`        | `float \| None` | वर्तमान शेष                                                                |
| `deposit`        | `str \| None`   | जमा पता                                                                    |
| `withdrawal_fee` | `float \| None` | निकासी शुल्क                                                               |

***

### `marketplace()`

क्लाइंट-साइड विकल्पी फिल्टर के साथ GPU मार्केटप्लेस खोजें।

```python
# सभी उपलब्ध सर्वर
servers = client.marketplace()

# GPU मॉडल और अधिकतम कीमत से फ़िल्टर करें
servers = client.marketplace(
    gpu="RTX 4090",
    max_price_usd=5.0
)

# बहु-GPU रिग जिनमें पर्याप्त RAM है
servers = client.marketplace(
    min_gpu_count=4,
    min_ram_gb=128.0
)
```

**पैरामीटर:**

| पैरामीटर         | प्रकार          | डिफ़ॉल्ट | वर्णन                                                        |
| ---------------- | --------------- | -------- | ------------------------------------------------------------ |
| `gpu`            | `str \| None`   | `None`   | GPU मॉडल द्वारा फ़िल्टर करें (केस-इनसेंसिटिव सबस्ट्रिंग मैच) |
| `min_gpu_count`  | `int \| None`   | `None`   | न्यूनतम GPU की संख्या                                        |
| `min_ram_gb`     | `float \| None` | `None`   | GB में न्यूनतम RAM                                           |
| `max_price_usd`  | `float \| None` | `None`   | USD में प्रति घंटे अधिकतम कीमत                               |
| `available_only` | `bool`          | `True`   | केवल वे सर्वर लौटाएँ जो किराए पर उपलब्ध हैं                  |

**परिणाम:** `List[MarketplaceServer]`

प्रत्येक `MarketplaceServer` अत्यधिक सामान्य फ़ील्ड्स के लिए सुविधाजनक गुण प्रदान करता है, साथ ही पूरा नेस्टेड डेटा तक पहुँच:

| प्रॉपर्टी        | प्रकार          | वर्णन                                                    |
| ---------------- | --------------- | -------------------------------------------------------- |
| `id`             | `int`           | विशिष्ट सर्वर ID                                         |
| `gpu_model`      | `str \| None`   | प्राथमिक GPU विवरण (उदा. `"1x NVIDIA GeForce RTX 4090"`) |
| `gpu_count`      | `int`           | GPU की संख्या (से `gpu_array`)                           |
| `ram_gb`         | `float \| None` | RAM GB में                                               |
| `price_usd`      | `float \| None` | ऑन-डिमांड कीमत USD में                                   |
| `spot_price_usd` | `float \| None` | स्पॉट कीमत USD में                                       |
| `available`      | `bool`          | क्या सर्वर उपलब्ध है (किराए पर नहीं गया)                 |
| `location`       | `str \| None`   | नेटवर्क स्पेस से देश कोड                                 |

उन्नत उपयोग मामलों के लिए, आप पूरा नेस्टेड स्ट्रक्चर एक्सेस कर सकते हैं:

| फ़ील्ड        | प्रकार                 | वर्णन                                                                                               |
| ------------- | ---------------------- | --------------------------------------------------------------------------------------------------- |
| `specs`       | `ServerSpecs \| None`  | पूर्ण हार्डवेयर विशिष्टताएँ (`specs.gpu`, `specs.ram`, `specs.cpu`, `specs.disk`, `specs.net`, आदि) |
| `price`       | `ServerPrice \| None`  | पूर्ण मूल्य ऑब्जेक्ट (`price.usd.on_demand_usd`, `price.usd.spot`, `price.on_demand`, आदि)          |
| `rented`      | `bool \| None`         | क्या सर्वर वर्तमान में किराए पर है                                                                  |
| `reliability` | `float \| None`        | सर्वर विश्वसनीयता स्कोर                                                                             |
| `rating`      | `ServerRating \| None` | सर्वर रेटिंग (`rating.avg`, `rating.cnt`)                                                           |

> **नोट:** द `marketplace()` एंडपॉइंट सार्वजनिक है — यह API कुंजी के बिना काम करता है।

***

### `my_servers()`

उन सर्वरों की सूची बनाएं जो आप Clore.ai मार्केटप्लेस को प्रदान कर रहे हैं।

```python
my_servers = client.my_servers()

for server in my_servers:
    print(f"{server.name}: {server.gpu_model} [{server.status}]")
```

**परिणाम:** `List[MyServer]`

| प्रॉपर्टी    | प्रकार          | वर्णन                                                                            |
| ------------ | --------------- | -------------------------------------------------------------------------------- |
| `id`         | `int`           | सर्वर ID                                                                         |
| `name`       | `str \| None`   | सर्वर नाम                                                                        |
| `gpu_model`  | `str \| None`   | प्राथमिक GPU विवरण                                                               |
| `ram_gb`     | `float \| None` | RAM GB में                                                                       |
| `status`     | `str`           | मानव-पठनीय स्थिति: `"Online"`, `"Offline"`, `"Disconnected"`, या `"Not Working"` |
| `connected`  | `bool \| None`  | क्या सर्वर कनेक्टेड है                                                           |
| `online`     | `bool \| None`  | क्या सर्वर ऑनलाइन है                                                             |
| `visibility` | `str \| None`   | `"public"` या `"private"`                                                        |

***

### `server_config(server_name)`

उस विशिष्ट सर्वर का कॉन्फ़िगरेशन प्राप्त करें जिसे आप होस्ट करते हैं।

```python
config = client.server_config("MyGPU")

print(f"Server: {config.name}")
print(f"GPU: {config.gpu_model}")
print(f"Min rental: {config.mrl}h")
print(f"On-demand: ${config.on_demand_price}")
print(f"Spot: ${config.spot_price}")
```

**पैरामीटर:**

| पैरामीटर      | प्रकार | वर्णन        |
| ------------- | ------ | ------------ |
| `server_name` | `str`  | सर्वर का नाम |

**परिणाम:** `ServerConfig`

| प्रॉपर्टी         | प्रकार                | वर्णन                            |
| ----------------- | --------------------- | -------------------------------- |
| `name`            | `str \| None`         | सर्वर नाम                        |
| `gpu_model`       | `str \| None`         | प्राथमिक GPU विवरण               |
| `mrl`             | `int \| None`         | घंटों में न्यूनतम किराये की अवधि |
| `on_demand_price` | `float \| None`       | पहली उपलब्ध ऑन-डिमांड USD कीमत   |
| `spot_price`      | `float \| None`       | पहली उपलब्ध स्पॉट USD कीमत       |
| `specs`           | `ServerSpecs \| None` | पूर्ण हार्डवेयर विनिर्देश        |
| `connected`       | `bool \| None`        | क्या सर्वर कनेक्टेड है           |
| `visibility`      | `str \| None`         | `"public"` या `"private"`        |

***

### `my_orders(include_completed)`

अप अपने वर्तमान ऑर्डर प्राप्त करें, वैकल्पिक रूप से पूर्ण/समाप्त ऑर्डर शामिल करके।

```python
# केवल सक्रिय ऑर्डर
orders = client.my_orders()

# पूर्ण ऑर्डर शामिल करें
all_orders = client.my_orders(include_completed=True)

for order in orders:
    print(f"Order {order.id}: {order.type} — {order.status}")
    if order.pub_cluster:
        print(f"  IP: {order.pub_cluster}")
    if order.tcp_ports:
        print(f"  Ports: {order.tcp_ports}")
```

**पैरामीटर:**

| पैरामीटर            | प्रकार | डिफ़ॉल्ट | वर्णन                         |
| ------------------- | ------ | -------- | ----------------------------- |
| `include_completed` | `bool` | `False`  | पूर्ण/समाप्त ऑर्डर शामिल करें |

**परिणाम:** `List[Order]`

| फ़ील्ड        | प्रकार          | वर्णन                               |
| ------------- | --------------- | ----------------------------------- |
| `id`          | `int`           | विशिष्ट ऑर्डर ID                    |
| `server_id`   | `int \| None`   | सर्वर ID                            |
| `type`        | `str`           | `"on-demand"` या `"spot"`           |
| `status`      | `str \| None`   | ऑर्डर स्थिति                        |
| `image`       | `str \| None`   | Docker इमेज                         |
| `currency`    | `str \| None`   | भुगतान मुद्रा                       |
| `price`       | `float \| None` | ऑर्डर की दैनिक कीमत                 |
| `pub_cluster` | `str \| None`   | एक्सेस के लिए सार्वजनिक होस्टनाम/IP |
| `tcp_ports`   | `dict \| None`  | TCP पोर्ट मैपिंग                    |

***

### `spot_marketplace(server_id)`

किसी विशिष्ट सर्वर के लिए स्पॉट मार्केट ऑफ़र देखें।

```python
spot = client.spot_marketplace(server_id=6)

if spot.offers:
    for offer in spot.offers:
        print(f"Order {offer.order_id}: ${offer.price}/day (server {offer.server_id})")

if spot.currency_rates_in_usd:
    for coin, rate in spot.currency_rates_in_usd.items():
        print(f"  {coin}: ${rate}")
```

**पैरामीटर:**

| पैरामीटर    | प्रकार | वर्णन                |
| ----------- | ------ | -------------------- |
| `server_id` | `int`  | जांच के लिए सर्वर ID |

**परिणाम:** `SpotMarket`

| फ़ील्ड                  | प्रकार                     | वर्णन                                                          |
| ----------------------- | -------------------------- | -------------------------------------------------------------- |
| `offers`                | `List[SpotOffer] \| None`  | स्पॉट ऑफ़र्स की सूची (`order_id`, `price`, `server_id`)        |
| `server`                | `SpotServerInfo \| None`   | सर्वर जानकारी (न्यूनतम मूल्य निर्धारण, दृश्यता, ऑनलाइन स्थिति) |
| `currency_rates_in_usd` | `Dict[str, float] \| None` | USD में मुद्रा विनिमय दरें                                     |

***

### `create_order(...)`

नया ऑन-डिमांड या स्पॉट ऑर्डर बनाएं। इसी तरह आप GPU किराए पर लेते हैं।

#### ऑन-डिमांड ऑर्डर

```python
order = client.create_order(
    server_id=123,
    image="cloreai/ubuntu22.04-cuda12",
    type="on-demand",
    currency="bitcoin",
    ssh_password="MySecurePass123",
    ports={"22": "tcp", "8888": "http"}
)

print(f"Order created: {order.id}")
print(f"Connect: {order.pub_cluster}")
```

#### स्पॉट ऑर्डर

```python
order = client.create_order(
    server_id=123,
    image="cloreai/pytorch",
    type="spot",
    currency="bitcoin",
    spot_price=0.000005,
    ssh_password="MySecurePass123",
    ports={"22": "tcp"}
)
```

**पैरामीटर:**

| पैरामीटर             | प्रकार  | आवश्यक     | वर्णन                                                       |
| -------------------- | ------- | ---------- | ----------------------------------------------------------- |
| `server_id`          | `int`   | हाँ        | किराए पर लेने के लिए सर्वर ID                               |
| `image`              | `str`   | हाँ        | Docker इमेज (उदा. `"cloreai/ubuntu22.04-cuda12"`)           |
| `type`               | `str`   | हाँ        | `"on-demand"` या `"spot"`                                   |
| `currency`           | `str`   | हाँ        | भुगतान मुद्रा (उदा. `"bitcoin"`)                            |
| `ssh_password`       | `str`   | नहीं       | SSH पासवर्ड (अल्फ़ान्यूमेरिक, अधिकतम 32 अक्षर)              |
| `ssh_key`            | `str`   | नहीं       | SSH सार्वजनिक कुंजी (अधिकतम 3072 अक्षर)                     |
| `ports`              | `dict`  | नहीं       | पोर्ट मैपिंग, उदाहरण के लिए `{"22": "tcp", "8888": "http"}` |
| `env`                | `dict`  | नहीं       | पर्यावरण वेरिएबल                                            |
| `jupyter_token`      | `str`   | नहीं       | Jupyter नोटबुक टोकन (अधिकतम 32 अक्षर)                       |
| `command`            | `str`   | नहीं       | कंटेनर शुरू होने के बाद चलाने के लिए शेल कमांड              |
| `spot_price`         | `float` | केवल स्पॉट | स्पॉट ऑर्डर्स के लिए प्रति दिन कीमत                         |
| `required_price`     | `float` | नहीं       | एक विशिष्ट कीमत लॉक करें (केवल ऑन-डिमांड)                   |
| `autossh_entrypoint` | `str`   | नहीं       | Clore.ai SSH एंट्रीपॉइंट का उपयोग करें                      |

**परिणाम:** `Order`

> **रेट लिमिट:** `create_order` कॉल्स के बीच एक विशेष 5-सेकंड कूलडाउन है। SDK इसे स्वचालित रूप से लागू करता है।

***

### `cancel_order(order_id, issue)`

एक सक्रिय ऑर्डर या स्पॉट ऑफ़र रद्द करें। वैकल्पिक रूप से सर्वर के साथ एक मुद्दा रिपोर्ट करें।

```python
# सरल रद्द करें
client.cancel_order(order_id=38)

# मुद्दा रिपोर्ट के साथ रद्द करें
client.cancel_order(
    order_id=38,
    issue="GPU #1 was overheating and throttling"
)
```

**पैरामीटर:**

| पैरामीटर   | प्रकार | आवश्यक | वर्णन                                                  |
| ---------- | ------ | ------ | ------------------------------------------------------ |
| `order_id` | `int`  | हाँ    | रद्द करने के लिए ऑर्डर ID                              |
| `issue`    | `str`  | नहीं   | रद्द करने का कारण / मुद्दा रिपोर्ट (अधिकतम 2048 अक्षर) |

**परिणाम:** `Dict[str, Any]`

***

### `set_server_settings(...)`

मार्केटप्लेस पर आप जो सर्वर होस्ट करते हैं उसके लिए सेटिंग्स अपडेट करें।

```python
client.set_server_settings(
    name="MyGPU",
    availability=True,
    mrl=96,
    on_demand=0.0001,
    spot=0.00000113
)
```

**पैरामीटर:**

| पैरामीटर       | प्रकार  | आवश्यक | वर्णन                               |
| -------------- | ------- | ------ | ----------------------------------- |
| `name`         | `str`   | हाँ    | सर्वर नाम                           |
| `availability` | `bool`  | नहीं   | क्या सर्वर किराए पर दिया जा सकता है |
| `mrl`          | `int`   | नहीं   | घंटों में न्यूनतम किराये की अवधि    |
| `on_demand`    | `float` | नहीं   | प्रति दिन ऑन-डिमांड कीमत            |
| `spot`         | `float` | नहीं   | प्रति दिन न्यूनतम स्पॉट कीमत        |

**परिणाम:** `Dict[str, Any]`

***

### `set_spot_price(order_id, price)`

अपने स्पॉट मार्केट ऑफ़र पर कीमत अपडेट करें।

```python
client.set_spot_price(order_id=39, price=0.000003)
```

**पैरामीटर:**

| पैरामीटर   | प्रकार  | वर्णन               |
| ---------- | ------- | ------------------- |
| `order_id` | `int`   | स्पॉट ऑर्डर/ऑफ़र ID |
| `price`    | `float` | नई प्रति दिन कीमत   |

**परिणाम:** `Dict[str, Any]`

> **नोट:** आप केवल हर 600 सेकंड में एक बार स्पॉट कीमतें घटा सकते हैं, और सीमित कदम आकार द्वारा। यदि आप इन सीमाओं को पार करते हैं तो API लौटाता है `code: 6` विवरण के साथ।

***

## असिंक क्लाइंट (`AsyncCloreAI`)

द `AsyncCloreAI` क्लाइंट वही विधियाँ प्रदान करता है जो `CloreAI`के हैं, लेकिन सभी कोरूटीन लौटाते हैं। जब आपको समांतर API कॉल की आवश्यकता हो या आप किसी असिंक्रोनस अनुप्रयोग के भीतर काम कर रहे हों तो इसे उपयोग करें।

### मूल उपयोग

```python
import asyncio
from clore_ai import AsyncCloreAI

async def main():
    async with AsyncCloreAI(api_key="your_key") as client:
        wallets = await client.wallets()
        for w in wallets:
            print(f"{w.name}: {w.balance:.8f}")

asyncio.run(main())
```

### समांतर संचालन

एक साथ कई API कॉल चलाएं `asyncio.gather`:

```python
import asyncio
from clore_ai import AsyncCloreAI

async def compare_gpus():
    async with AsyncCloreAI() as client:
        # एक साथ कई GPU मॉडलों के लिए खोजें
        rtx4090, rtx3090, a100 = await asyncio.gather(
            client.marketplace(gpu="RTX 4090"),
            client.marketplace(gpu="RTX 3090"),
            client.marketplace(gpu="A100"),
        )

        for name, servers in [("RTX 4090", rtx4090), ("RTX 3090", rtx3090), ("A100", a100)]:
            if servers:
                cheapest = min(s.price_usd or float('inf') for s in servers)
                print(f"{name}: {len(servers)} available, cheapest ${cheapest:.4f}/h")
            else:
                print(f"{name}: none available")

asyncio.run(compare_gpus())
```

### उपलब्ध विधियाँ

`AsyncCloreAI` सभी वही विधियाँ समर्थित हैं जो `CloreAI`:

| विधि                                | वर्णन                             |
| ----------------------------------- | --------------------------------- |
| `await wallets()`                   | वॉलेट शेष प्राप्त करें            |
| `await marketplace(...)`            | मार्केटप्लेस खोजें                |
| `await my_servers()`                | आपके होस्ट किए गए सर्वरों की सूची |
| `await server_config(name)`         | सर्वर कॉन्फ़िगरेशन प्राप्त करें   |
| `await my_orders(...)`              | आपके ऑर्डर की सूची                |
| `await spot_marketplace(server_id)` | स्पॉट मार्केट ऑफ़र प्राप्त करें   |
| `await create_order(...)`           | नया ऑर्डर बनाएं                   |
| `await cancel_order(...)`           | एक ऑर्डर रद्द करें                |
| `await set_server_settings(...)`    | सर्वर सेटिंग्स अपडेट करें         |
| `await set_spot_price(...)`         | स्पॉट कीमत अपडेट करें             |

***

## त्रुटि हैंडलिंग

SDK प्रत्येक API त्रुटि कोड के लिए संरचित अपवाद कक्षाएं प्रदान करता है।

```python
from clore_ai import CloreAI
from clore_ai.exceptions import (
    CloreAPIError,      # सभी API त्रुटियों के लिए बेस क्लास
    AuthError,          # कोड 3 — अवैध API कुंजी
    RateLimitError,     # कोड 5 — दर-सीमा पार
    InvalidInputError,  # कोड 2 — खराब अनुरोध डेटा
    DBError,            # कोड 1 — डेटाबेस त्रुटि
    InvalidEndpointError,  # कोड 4 — अवैध एंडपॉइंट
    FieldError,         # कोड 6 — फ़ील्ड-विशिष्ट त्रुटि
)

client = CloreAI()

try:
    order = client.create_order(
        server_id=123,
        image="cloreai/ubuntu22.04-cuda12",
        type="on-demand",
        currency="bitcoin",
    )
except AuthError:
    print("अमान्य API कुंजी। अपनी CLORE_API_KEY जांचें.")
except RateLimitError:
    print("रेट लिमिट पार हुई। SDK स्वचालित रूप से पुन: प्रयास करता है, लेकिन आपने अधिकतम पुन: प्रयास सीमा पार कर दी है.")
except InvalidInputError as e:
    print(f"खराब अनुरोध: {e}")
except FieldError as e:
    # कोड 6 त्रुटियों में प्रतिक्रिया में विवरण शामिल होते हैं
    print(f"फ़ील्ड त्रुटि: {e} (विवरण: {e.response})")
except CloreAPIError as e:
    print(f"API त्रुटि: {e} (कोड: {e.code})")
```

### त्रुटि कोड

| कोड | अपवाद                  | वर्णन                                                             |
| --- | ---------------------- | ----------------------------------------------------------------- |
| 0   | —                      | सफलता                                                             |
| 1   | `DBError`              | डेटाबेस त्रुटि                                                    |
| 2   | `InvalidInputError`    | अमान्य इनपुट डेटा                                                 |
| 3   | `AuthError`            | अमान्य API टोकन                                                   |
| 4   | `InvalidEndpointError` | अमान्य एंडपॉइंट                                                   |
| 5   | `RateLimitError`       | रेट लिमिट पार हुई                                                 |
| 6   | `FieldError`           | विशिष्ट फ़ील्ड में त्रुटि (देखें `त्रुटि` प्रतिक्रिया में फ़ील्ड) |

सभी अपवाद क्लासेस वारिस होते हैं `CloreAPIError` और इनमें शामिल हैं:

* `e.code` — संख्यात्मक त्रुटि कोड
* `e.response` — पूर्ण API प्रतिक्रिया dict (जब उपलब्ध हो)

***

## रेट लिमिटिंग

SDK में एक अंतर्निर्मित रेट लिमिटर शामिल है जो स्वचालित रूप से Clore.ai की सीमाओं को लागू करता है:

| एंडपॉइंट         | सीमा                 |
| ---------------- | -------------------- |
| अधिकांश एंडपॉइंट | **1 अनुरोध/सेकंड**   |
| `create_order`   | **1 अनुरोध/5 सेकंड** |

जब API रेट-लिमिट त्रुटि (कोड 5) लौटाता है, SDK लागू करता है **घातीय बैकऑफ** और पुन: प्रयास करता है तक `max_retries` बार (डिफ़ॉल्ट: 3). आपको जोड़ने की आवश्यकता नहीं है `time.sleep()` कॉल्स के बीच।

### यह कैसे काम करता है

1. प्रत्येक अनुरोध से पहले, रेट लिमिटर न्यूनतम अंतराल के समाप्त होने तक प्रतीक्षा करता है।
2. `create_order` कॉल्स एक अतिरिक्त 5-सेकंड कूलडाउन लागू करते हैं।
3. रेट-लिमिट त्रुटियों पर, SDK घातीय रूप से पीछे हटता है: 1s → 2s → 4s → ...
4. के बाद `max_retries` असफल प्रयासों, एक `RateLimitError` उठाया जाता है।

### पुन: प्रयास व्यवहार अनुकूलित करें

```python
client = CloreAI(
    max_retries=5,    # लंबी चलने वाली स्क्रिप्ट्स के लिए अधिक पुन: प्रयास
    timeout=60.0      # धीमे कनेक्शनों के लिए लंबा टाइमआउट
)
```

***

## कॉन्फ़िगरेशन

### कॉन्फ़िग फ़ाइल

CLI कॉन्फ़िगरेशन को संग्रहीत करता है `~/.clore/config.json`:

```json
{
  "api_key": "your_api_key_here"
}
```

### रिज़ॉल्यूशन क्रम

SDK इस क्रम में API कुंजी हल करता है:

1. `api_key` कंस्ट्रक्टर को पास किया गया आर्गुमेंट
2. `CLORE_API_KEY` पर्यावरण चर
3. `api_key` में फ़ील्ड `~/.clore/config.json`

### पर्यावरण वेरिएबल

| वेरिएबल         | वर्णन                       |
| --------------- | --------------------------- |
| `CLORE_API_KEY` | प्रमाणीकरण के लिए API कुंजी |

***

## अगले कदम

* [**CLI संदर्भ**](/clore.ai/clore.ai-eng-hi/developers/cli-guide.md) — अपने टर्मिनल से Clore.ai का उपयोग करें
* [**REST API**](/clore.ai/clore.ai-eng-hi/for-hosts/api.md) — कस्टम एकीकरण के लिए रॉ API दस्तावेज़
* [**ऑन-डिमांड बनाम स्पॉट**](/clore.ai/clore.ai-eng-hi/for-renters/on-demand-vs-spot.md) — मूल्य निर्धारण मॉडल को समझें
* [**उपलब्ध Docker इमेजेज़**](/clore.ai/clore.ai-eng-hi/for-renters/docker-images.md) — GPU वर्कलोड्स के लिए पूर्व-निर्मित इमेजेज़


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/clore.ai/clore.ai-eng-hi/developers/python-sdk.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.