> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/clore.ai/clore.ai-eng-hi/developers/python-sdk.md).

# Python SDK (clore-ai)

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

***

## स्थापना

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

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

पैकेज Python SDK और [`clore` CLI](/clore.ai/clore.ai-eng-hi/developers/cli-guide.md).

***

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

अपना API key प्राप्त करें [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 पर वापस जाता है
    base_url: str | None = None,       # डिफ़ॉल्ट: https://api.clore.ai/v1
    timeout: float = 30.0,             # सेकंड में अनुरोध समय-सीमा
    max_retries: int = 3               # rate-limit / नेटवर्क त्रुटियों पर पुनः प्रयास
)
```

क्लाइंट स्वचालित सफाई के लिए संदर्भ प्रबंधकों का समर्थन करता है:

```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]`

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

***

### `marketplace()`

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

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

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

# पर्याप्त RAM वाले मल्टी-GPU rigs
servers = client.marketplace(
    min_gpu_count=4,
    min_ram_gb=128.0
)
```

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

| पैरामीटर         | प्रकार          | डिफ़ॉल्ट | विवरण                                                               |
| ---------------- | --------------- | -------- | ------------------------------------------------------------------- |
| `gpu`            | `str \| None`   | `None`   | GPU मॉडल के आधार पर फ़िल्टर करें (केस-इन्सेंसिटिव उपस्ट्रिंग मिलान) |
| `min_gpu_count`  | `int \| None`   | `None`   | GPUs की न्यूनतम संख्या                                              |
| `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`           | GPUs की संख्या (from `gpu_array`)                        |
| `ram_gb`         | `float \| None` | GB में RAM                                               |
| `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()` endpoint सार्वजनिक है — यह API key के बिना काम करता है।

***

### `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                                                                         |
| `नाम`        | `str \| None`   | सर्वर नाम                                                                        |
| `gpu_model`  | `str \| None`   | प्राथमिक GPU विवरण                                                               |
| `ram_gb`     | `float \| None` | GB में RAM                                                                       |
| `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`

| गुण               | प्रकार                | विवरण                           |
| ----------------- | --------------------- | ------------------------------- |
| `नाम`             | `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 notebook token (अधिकतम 32 वर्ण)                                                                                                                                                |
| `command`            | `str`       | नहीं       | कंटेनर शुरू होने के बाद चलाने के लिए शेल कमांड                                                                                                                                         |
| `spot_price`         | `float`     | केवल स्पॉट | स्पॉट ऑर्डरों के लिए प्रति दिन मूल्य                                                                                                                                                   |
| `required_price`     | `float`     | नहीं       | एक विशिष्ट मूल्य लॉक करें (केवल ऑन-डिमांड)                                                                                                                                             |
| `autossh_entrypoint` | `str`       | नहीं       | Clore.ai SSH प्रवेशबिंदु का उपयोग करें                                                                                                                                                 |
| `gpu_count`          | `int`       | नहीं       | केवल N GPU उन सर्वरों पर किराये पर लें जिनमें [आंशिक किराया](/clore.ai/clore.ai-eng-hi/for-renters/partial-gpu-rental.md) (केवल ऑन-डिमांड); पूरे रिग को किराये पर लेने के लिए छोड़ दें |
| `gpu_indices`        | `list[int]` | नहीं       | से सटीक GPU स्लॉट `partial_gpu_rental.free_indices`; लंबाई बराबर होनी चाहिए `gpu_count`; ऑटो-पिक के लिए छोड़ दें                                                                       |

**लौटाता है:** कच्चा API उत्तर (`{"code": 0}` सफलता पर); बनाए गए ऑर्डर को प्राप्त करें `my_orders()`

> **रेट लिमिट:** `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 ज़्यादा गरम हो रहा था और थ्रॉटलिंग कर रहा था"
)
```

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

| पैरामीटर   | प्रकार | आवश्यक | विवरण                                                 |
| ---------- | ------ | ------ | ----------------------------------------------------- |
| `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
)
```

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

| पैरामीटर       | प्रकार  | आवश्यक | विवरण                                |
| -------------- | ------- | ------ | ------------------------------------ |
| `नाम`          | `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 कॉल्स की आवश्यकता हो या आप किसी async एप्लिकेशन के भीतर काम कर रहे हों, तब इसका उपयोग करें।

### बुनियादी उपयोग

```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)】【：】【“】【t_51f4a1e9":"if servers:","t_820bbc0c":"cheapest = min(s.price_usd or float('inf') for s in servers)","t_678b9403":"print(f\"{name}: {len(servers)} उपलब्ध, सबसे सस्ता ${cheapest:.4f}/घंटा\")","t_5638f476":"else:","t_da393439":"print(f\"{name}: कोई उपलब्ध नहीं\")","t_3774ff64":"asyncio.run(compare_gpus())","t_6411125b":"उपलब्ध विधियाँ","t_b07622cb":"जैसी ही सभी विधियों का समर्थन करता है","t_ea832922":"विधि","t_3e4879db":"await wallets()","t_06414578":"वॉलेट शेष राशि प्राप्त करें","t_3fcdaeec":"await marketplace(...)","t_38ef9fa7":"मार्केटप्लेस खोजें","t_b7b9edc2":"await my_servers()","t_a1b26713":"अपने होस्ट किए गए सर्वर सूचीबद्ध करें","t_be0bd32c":"await server_config(name)","t_6cd5bb18":"सर्वर कॉन्फ़िगरेशन प्राप्त करें","t_0bad7428":"await my_orders(...)","t_a170c652":"अपने ऑर्डर सूचीबद्ध करें","t_d75902c8":"await spot_marketplace(server_id)","t_4f50d8d0":"स्पॉट मार्केट ऑफ़र प्राप्त करें","t_98a830c7":"await create_order(...)","t_d8106b4b":"एक नया ऑर्डर बनाएँ","t_ad7b0c2c":"await cancel_order(...)","t_e7eb9b9c":"एक ऑर्डर रद्द करें","t_d58b6db7":"await set_server_settings(...)","t_13fa9bb7":"सर्वर सेटिंग्स अपडेट करें","t_d4d22b25":"await set_spot_price(...)","t_0acaf56d":"स्पॉट मूल्य अपडेट करें","t_9765ba4c":"त्रुटि प्रबंधन","t_cb05dea0":"SDK हर API त्रुटि कोड के लिए संरचित अपवाद वर्ग प्रदान करता है।","t_de708f50":"from clore_ai.exceptions import (","t_8f08e459":"CloreAPIError,      # सभी API त्रुटियों के लिए आधार वर्ग","t_9f474ac2":"AuthError,          # Code 3 — अमान्य API key","t_0545e782":"RateLimitError,     # Code 5 — रेट लिमिट पार हो गई","t_ef0fc8c8":"InvalidInputError,  # Code 2 — गलत अनुरोध डेटा","t_71cdcb89":"DBError,            # Code 1 — डेटाबेस त्रुटि","t_12c7b3be":"InvalidEndpointError,  # Code 4 — अमान्य एंडपॉइंट","t_a3dab3c0":"FieldError,         # Code 6 — फ़ील्ड-विशिष्ट त्रुटि","t_23add6d8":"try:","t_35ddf277":"except AuthError:","t_2cab1e35":"print(\"अमान्य API key. अपनी CLORE_API_KEY जाँचें।\")","t_114fcc19":"except RateLimitError:","t_581e327c":"print(\"रेट लिमिट लागू है। SDK स्वचालित रूप से पुनः प्रयास करता है, लेकिन आप अधिकतम पुनः प्रयासों तक पहुँच गए।\")","t_da781e1e":"except InvalidInputError as e:","t_638de865":"print(f\"गलत अनुरोध: {e}\")","t_4374d6b1":"except FieldError as e:","t_910583ba":"# Code 6 त्रुटियों के विवरण उत्तर में शामिल होते हैं","t_e7dec1c3":"print(f\"फ़ील्ड त्रुटि: {e} (विवरण: {e.response})\")","t_7d507c73":"except CloreAPIError as e:","t_f7138530":"print(f\"API त्रुटि: {e} (code: {e.code})\")","t_9591be2f":"त्रुटि कोड","t_d4642fd2":"Code","t_dda2ac35":"Exception","t_65c16081":"—","t_380c9393":"सफलता","t_a954e6af":"DBError","t_73134917":"डेटाबेस त्रुटि","t_f58ceeca":"InvalidInputError","t_93990a3d":"अमान्य इनपुट डेटा","t_5f728228":"AuthError","t_35c7b21c":"अमान्य API token","t_da8db636":"InvalidEndpointError","t_1812b710":"अमान्य एंडपॉइंट","t_6fea027d":"RateLimitError","t_57a65e96":"रेट लिमिट पार हो गई","t_7303b606":"FieldError","t_375e3da5":"विशिष्ट फ़ील्ड में त्रुटि (देखें","t_ed9d12ad":"error","t_3ebfb6f5":"प्रतिक्रिया में field)","t_e7f1ea79":"सभी अपवाद वर्ग विरासत में लेते हैं","t_491b71ae":"CloreAPIError","t_e4a04410":"और इनमें शामिल हैं:","t_6daf32a1":"e.code","t_4c29ba67":"— संख्यात्मक त्रुटि कोड","t_e4364985":"e.response","t_3ab61f01":"— पूर्ण API response dict (जब उपलब्ध हो)","t_e1062da5":"रेट लिमिटिंग","t_a8f5d1f6":"SDK में एक अंतर्निहित रेट लिमिटर शामिल है जो Clore.ai की सीमाओं को स्वचालित रूप से लागू करता है:","t_1aa84d6d":"एंडपॉइंट","t_c5b2737e":"सीमा","t_813d8eef":"अधिकांश एंडपॉइंट","t_9d4386fb":"1 अनुरोध/सेकंड","t_448ce96e":"1 अनुरोध/5 सेकंड","t_1c7cd5e2":"जब API एक रेट-लिमिट त्रुटि (code 5) लौटाती है, तो SDK लागू करता है","t_4981dc3c":"घातीय बैकऑफ़","t_d50a6734":"और तक पुनः प्रयास करता है","t_3eb92206":"max_retries","t_1ce3a9ca":"बार (डिफ़ॉल्ट: 3)। आपको जोड़ने की आवश्यकता नहीं है","t_f689842d":"time.sleep()","t_a0729779":"कॉल्स के बीच।","t_2499a66f":"यह कैसे काम करता है","t_b3914ed9":"प्रत्येक अनुरोध से पहले, रेट लिमिटर न्यूनतम अंतराल समाप्त होने तक प्रतीक्षा करता है।","t_c8aed133":"कॉल्स एक अतिरिक्त 5-सेकंड कूलडाउन लागू करती हैं।","t_f1852980":"रेट-लिमिट त्रुटियों पर, SDK घातीय रूप से पीछे हटता है: 1s → 2s → 4s → ...","t_e2fa0187":"के बाद","t_acdda1e2":"विफल प्रयासों के बाद, एक","t_a7fc9a8a":"फेंका जाता है।","t_9aee3b1e":"पुनः प्रयास व्यवहार अनुकूलित करें","t_6c048813":"client = CloreAI(","t_68f4328f":"max_retries=5,    # लंबे समय चलने वाली स्क्रिप्ट्स के लिए अधिक पुनः प्रयास","t_502311a4":"timeout=60.0      # धीमे कनेक्शनों के लिए अधिक समय-सीमा","t_3408e709":"कॉन्फ़िगरेशन","t_45e0918d":"कॉन्फ़िग फ़ाइल","t_b042389c":"CLI कॉन्फ़िगरेशन को इसमें संग्रहीत करता है","t_1482a2a2":"\"api_key\": \"your_api_key_here\"","t_f0bbaecf":"समाधान क्रम","t_67592675":"SDK API key को इस क्रम में हल करता है:","t_e99c2d0a":"api_key","t_e3193fc7":"कन्स्ट्रक्टर को पास किया गया आर्गुमेंट","t_62d0b250":"पर्यावरण चर","t_d9a49e74":"में फ़ील्ड","t_26756975":"चर","t_37e588fd":"प्रमाणीकरण के लिए API key","t_7479aba4":"अगले चरण","t_8524f923":"CLI संदर्भ","t_ad3a0af0":"— अपने टर्मिनल से Clore.ai का उपयोग करें","t_d4eeecd4":"REST API","t_03b32d18":"— कस्टम इंटीग्रेशन के लिए कच्चा API दस्तावेज़","t_64ad1d99":"ऑन-डिमांड बनाम स्पॉट","t_cde91326":"— मूल्य निर्धारण मॉडल समझें","t_8c119578":"उपलब्ध Docker इमेज","t_055ff5e5":"— GPU वर्कलोड के लिए पूर्व-निर्मित इमेज"}】result  }.]}]...  എന്നിവ]}]}']}]}]}]}]}]}]}]}】}]}]}'}]}]}]}]}]}]}]}]}]}]}}]}]}]}]}]}]}]}]}}}]}]}]}```json only? Wait output has junk due accidental corruption. Need correct final valid JSON only. Ensure no extraneous characters. Let's provide clean object. Need fix some translations maybe t_7b8026df etc. Also need valid JSON, no weird output. Let's produce complete JSON carefully, maybe simpler to avoid syntax issues. Check t_8a437611 maybe maybe 
            if servers:
                ...
                ...
            else:
                print(...)

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,          # Code 3 — अमान्य API key
    RateLimitError,     # Code 5 — रेट लिमिट पार हो गई
    InvalidInputError,  # Code 2 — गलत अनुरोध डेटा
    DBError,            # Code 1 — डेटाबेस त्रुटि
    InvalidEndpointError,  # Code 4 — अमान्य एंडपॉइंट
    FieldError,         # Code 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 key. अपनी CLORE_API_KEY जाँचें।")
except RateLimitError:
    print("रेट लिमिट लागू है। SDK स्वचालित रूप से पुनः प्रयास करता है, लेकिन आप अधिकतम पुनः प्रयासों तक पहुँच गए।")
except InvalidInputError as e:
    print(f"गलत अनुरोध: {e}")
except FieldError as e:
    # Code 6 त्रुटियों के विवरण उत्तर में शामिल होते हैं
    print(f"फ़ील्ड त्रुटि: {e} (विवरण: {e.response})")
except CloreAPIError as e:
    print(f"API त्रुटि: {e} (code: {e.code})")
```

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

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

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

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

***

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

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

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

जब API एक रेट-लिमिट त्रुटि (code 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 key को इस क्रम में हल करता है:

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

### पर्यावरण चर

| चर              | विवरण                     |
| --------------- | ------------------------- |
| `CLORE_API_KEY` | प्रमाणीकरण के लिए API key |

***

## अगले चरण

* [**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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.