#league-of-legends #lol #tft #teamfight-tactics

ddragon

Library for pulling data from ddragon, with caching support

14 releases (7 breaking)

0.8.1 Oct 31, 2023
0.7.4 Jul 28, 2023
0.7.1 Mar 17, 2023

#66 in Games

Download history 262/week @ 2023-10-31 29/week @ 2023-11-07 26/week @ 2023-11-14 324/week @ 2023-11-21 63/week @ 2023-11-28 18/week @ 2023-12-05 29/week @ 2023-12-12 37/week @ 2023-12-19 63/week @ 2023-12-26 90/week @ 2024-01-02 73/week @ 2024-01-09 33/week @ 2024-01-16 85/week @ 2024-01-23 74/week @ 2024-01-30 33/week @ 2024-02-06 94/week @ 2024-02-13

299 downloads per month
Used in 2 crates

MIT license

71KB
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.4–43MB
~645K SLoC