Rate Limits

import time
import requests

def fetch_with_retry(url, headers, max_retries=5):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)

        if response.status_code == 429:
            retry_after = response.headers.get("Retry-After")
            wait_time = int(retry_after) if retry_after else 2 ** attempt
            print(f"Rate limited. Retrying in {wait_time}s...")
            time.sleep(wait_time)
            continue

        response.raise_for_status()
        return response

    raise Exception("Max retries exceeded")

async function fetchWithRetry(
  url: string,
  headers: Record<string, string>,
  maxRetries = 5
): Promise<Response> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, { headers });

    if (response.status === 429) {
      const retryAfter = response.headers.get("Retry-After");
      const waitTime = retryAfter
        ? parseInt(retryAfter, 10) * 1000
        : 2 ** attempt * 1000;
      console.log(`Rate limited. Retrying in ${waitTime / 1000}s...`);
      await new Promise((r) => setTimeout(r, waitTime));
      continue;
    }

    if (!response.ok) {
      throw new Error(`Request failed: ${response.status}`);
    }
    return response;
  }

  throw new Error("Max retries exceeded");
}

func fetchWithRetry(url, apiKey string, maxRetries int) (*http.Response, error) {
    for attempt := 0; attempt < maxRetries; attempt++ {
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Set("X-Avala-Api-Key", apiKey)

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }

        if resp.StatusCode == 429 {
            retryAfter := resp.Header.Get("Retry-After")
            var waitTime time.Duration
            if seconds, err := strconv.Atoi(retryAfter); err == nil {
                waitTime = time.Duration(seconds) * time.Second
            } else {
                waitTime = time.Duration(1<<uint(attempt)) * time.Second
            }
            log.Printf("Rate limited. Retrying in %v...", waitTime)
            time.Sleep(waitTime)
            resp.Body.Close()
            continue
        }

        return resp, nil
    }

    return nil, fmt.Errorf("max retries exceeded")
}

#!/bin/bash
MAX_RETRIES=5
ATTEMPT=0

while [ $ATTEMPT -lt $MAX_RETRIES ]; do
  HTTP_CODE=$(curl -s -o response.json -w "%{http_code}" \
    "https://api.avala.ai/api/v1/datasets/johndoe/list/" \
    -H "X-Avala-Api-Key: $AVALA_API_KEY")

  if [ "$HTTP_CODE" -eq 429 ]; then
    WAIT=$((2 ** ATTEMPT))
    echo "Rate limited. Retrying in ${WAIT}s..."
    sleep $WAIT
    ATTEMPT=$((ATTEMPT + 1))
  else
    cat response.json
    break
  fi
done

import requests

BASE_URL = "https://api.avala.ai/api/v1"
headers = {"X-Avala-Api-Key": "YOUR_API_KEY"}

def fetch_all_datasets(owner):
    all_datasets = []
    url = f"{BASE_URL}/datasets/{owner}/list/"

    while url:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        data = response.json()

        all_datasets.extend(data["results"])
        url = data.get("next")

    return all_datasets

const BASE_URL = "https://api.avala.ai/api/v1";
const headers = { "X-Avala-Api-Key": "YOUR_API_KEY" };

async function fetchAllDatasets(owner: string) {
  const allDatasets: any[] = [];
  let url: string | null =
    `${BASE_URL}/datasets/${owner}/list/`;

  while (url) {
    const response = await fetch(url, { headers });
    if (!response.ok) {
      throw new Error(`Request failed: ${response.status}`);
    }
    const data = await response.json();

    allDatasets.push(...data.results);
    url = data.next;
  }

  return allDatasets;
}

func fetchAllDatasets(owner, apiKey string) ([]map[string]interface{}, error) {
    var allDatasets []map[string]interface{}
    url := fmt.Sprintf(
        "https://api.avala.ai/api/v1/datasets/%s/list/", owner,
    )

    for url != "" {
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Set("X-Avala-Api-Key", apiKey)

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }

        var result struct {
            Next    *string                  `json:"next"`
            Results []map[string]interface{} `json:"results"`
        }
        json.NewDecoder(resp.Body).Decode(&result)
        resp.Body.Close()

        allDatasets = append(allDatasets, result.Results...)

        if result.Next != nil {
            url = *result.Next
        } else {
            url = ""
        }
    }

    return allDatasets, nil
}

# Fetch all pages using cursor-based pagination
URL="https://api.avala.ai/api/v1/datasets/johndoe/list/"

while [ -n "$URL" ] && [ "$URL" != "null" ]; do
  RESPONSE=$(curl -s "$URL" \
    -H "X-Avala-Api-Key: $AVALA_API_KEY")

  echo "$RESPONSE" | jq '.results'

  URL=$(echo "$RESPONSE" | jq -r '.next')
done