#league-of-legends #lol #tft #api-client #deserializable #api-bindings #teamfight-tactics

ddragon

Library for pulling data from ddragon, with caching support

16 releases

new 0.8.3 Nov 29, 2024
0.8.2 Apr 5, 2024
0.8.1 Oct 31, 2023
0.7.4 Jul 28, 2023
0.7.1 Mar 17, 2023

#1 in #lol

Download history 28/week @ 2024-08-12 100/week @ 2024-08-19 19/week @ 2024-08-26 1/week @ 2024-09-02 17/week @ 2024-09-09 55/week @ 2024-09-16 43/week @ 2024-09-23 9/week @ 2024-09-30 26/week @ 2024-10-07 16/week @ 2024-10-14 83/week @ 2024-10-21 43/week @ 2024-10-28 47/week @ 2024-11-04 20/week @ 2024-11-11 9/week @ 2024-11-18 200/week @ 2024-11-25

283 downloads per month
Used in 2 crates

MIT license

74KB
1.5K SLoC

ddragon

latest version health check status downloads of latest version latest docs

Rust library for accessing the latest League of Legends patch's ddragon data.

  • Fully (de)serializable, well-typed structs
  • Supports TFT data
  • Provides a synchronous API by default
    • Local caching via cacache
    • Accepts custom ureq agents (which can use the exposed cache middleware)
  • Optionally, an asynchronous API can be used that maintains the same featureset
    • Local caching is handled by http-cache-reqwest rather than a custom middleware
    • Also accepts custom reqwest or reqwest-middleware clients
  • Optionally, some useful functions to fetch and decode images, via image

Usage

use ddragon::{cache_middleware::CacheMiddleware, Client, ClientBuilder, ClientError};

fn main() -> Result<(), ClientError> {
    let client = Client::new("/path/to/your/cache/dir")?;

    // If you want to use an existing agent
    let my_agent = ureq::AgentBuilder::new()
        .middleware(CacheMiddleware::new("/path/to/your/cache/dir"))
        .build();
    let client = ClientBuilder::new().agent(my_agent).build()?;

    // See available options on the client and in the models folder.
    let champions = client.champions()?;
    let runes = client.runes()?;
    let tft_items = client.tft_items()?;

    Ok(())
}

Features

The following crate features are available:

  • sync (on by default) enables the synchronous client.

    • Provides the ddragon::client and ddragon::cache_middleware module.
    • Provides the re-exported ddragon::Client and ddragon::ClientBuilder impls.
    • Adds cacache, url, thiserror, and ureq with the json feature enabled as dependencies.
  • async enables the asynchronous client.

    • Provides the ddragon::async_client module.
    • Provides the re-exported ddragon::AsyncClient and ddragon::AsyncClientBuilder impls.
    • Adds reqwest with the json feature, reqwest-middleware and http-cache-reqwest as dependencies.
    • If you would like the client to use rustls, use the async-rustls feature instead.
  • image enables image fetching and caching.

    • Both clients will receive image_of and sprite_of for any model which implements HasImage.
    • Adds the image dependency.
  • To use the library with just the synchronous version, it should be as simple as adding any other dependency:

[dependencies]
ddragon = "<version>"
  • If you would also like to have the image fetching support, use:
[dependencies]
ddragon = { version = "<version>", features = ["image"] }
  • If you want the asynchronous client only, you probably don't want to pull in the dependencies related to the synchronous code, so you can do this:
[dependencies]
ddragon = { version = "<version>", default-features = false, features = ["async"] }
  • If you want the async client and you want to use rustls (and you want ddragon to generate the client), you can use:
[dependencies]
ddragon = { version = "<version>", default-features = false, features = ["async-rustls"] }

Note that if you are providing your own client (via AsyncClientBuilder::new().agent()) you can use either async feature set.

  • If you only want the DDragon models (none of the client code), you can use
[dependencies]
ddragon = { version = "<version>", default-features = false }

MSRV

Currently, this crate support Rust >= 1.67.1.

Dependencies

~0.3–34MB
~561K SLoC