ChessDB API

Kopírovat// ChessDB API client (vanilla JS / Node.js)

const API_KEY  = 'váš_api_klíč';
const BASE_URL = 'https://chessdb.cz/chessdb-api.php';

async function searchGames(params) {
  const url = new URL(BASE_URL);
  url.searchParams.set('resource', 'games');
  for (const [key, value] of Object.entries(params)) {
    url.searchParams.set(key, value);
  }

  const response = await fetch(url, {
    headers: { 'Authorization': `Bearer ${API_KEY}` },
  });

  if (!response.ok) {
    const err = await response.json();
    throw new Error(err.error?.message ?? 'Unknown error');
  }

  return response.json();
}

// Příklad použití
const result = await searchGames({
  q:         'Novak',
  side:      'white',
  year_from: 2020,
  per_page:  20,
});

console.log(`Nalezeno ${result.meta.total} partií`);
result.data.forEach(g => console.log(g.white, 'vs', g.black, g.result));

// Stránkování přes všechny výsledky
async function fetchAllPages(params) {
  const games = [];
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const res = await searchGames({ ...params, page });
    games.push(...res.data);
    hasMore = res.meta.has_more;
    page++;
  }
  return games;
}

Kopírovatimport requests
from typing import Any, Iterator

API_KEY  = "váš_api_klíč"
BASE_URL = "https://chessdb.cz/chessdb-api.php"

class ChessDBClient:
    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}"
        })

    def search_games(self, q: str, **kwargs) -> dict[str, Any]:
        resp = self.session.get(BASE_URL, params={
            "resource": "games",
            "q": q,
            **kwargs
        })
        resp.raise_for_status()
        return resp.json()

    def get_game(self, game_id: int) -> dict[str, Any]:
        resp = self.session.get(BASE_URL, params={
            "resource": "game",
            "id": game_id
        })
        resp.raise_for_status()
        return resp.json()["data"]

    def iter_pages(self, q: str, **kwargs) -> Iterator[list]:
        """Iterátor přes všechny stránky výsledků."""
        page = 1
        while True:
            result = self.search_games(q, page=page, per_page=50, **kwargs)
            yield result["data"]
            if not result["meta"]["has_more"]:
                break
            page += 1


# Příklad použití
client = ChessDBClient(API_KEY)

result = client.search_games(
    q="Novak",
    side="white",
    year_from=2020,
    eco="E60"
)
print(f"Nalezeno {result['meta']['total']} partií")

# Uložení PGN souborů
for page_games in client.iter_pages("Novak"):
    for game in page_games:
        filename = f"game_{game['id']}.pgn"
        with open(filename, "w") as f:
            f.write(game["pgn"])

Kopírovat

class ChessDBClient {
    private string $apiKey;
    private string $baseUrl = 'https://chessdb.cz/chessdb-api.php';

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    /** @param array<string,mixed> $params */
    public function searchGames(string $q, array $params = []): array {
        return $this->request(array_merge(
            ['resource' => 'games', 'q' => $q],
            $params
        ));
    }

    public function getGame(int $id): array {
        return $this->request(['resource' => 'game', 'id' => $id])['data'];
    }

    private function request(array $params): array {
        $url = $this->baseUrl . '?' . http_build_query($params);
        $ctx = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => "Authorization: Bearer {$this->apiKey}\r\n",
                'ignore_errors' => true,
            ],
        ]);

        $body = file_get_contents($url, false, $ctx);
        if ($body === false) {
            throw new RuntimeException('HTTP request failed');
        }

        $data = json_decode($body, true);
        if (isset($data['error'])) {
            throw new RuntimeException($data['error']['message']);
        }
        return $data;
    }
}

// Použití
$client = new ChessDBClient('váš_api_klíč');

$result = $client->searchGames('Novak', [
    'side'      => 'white',
    'year_from' => 2022,
    'per_page'  => 50,
]);

echo "Nalezeno: {$result['meta']['total']} partií\n";
foreach ($result['data'] as $game) {
    echo "{$game['white']} vs {$game['black']} – {$game['result']}\n";
}