Skip to content

Cache

pokelance.cache.cache ⚓︎

AbilityCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Ability']

A cache for abilities.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

BaseCache(max_size=100) ⚓︎

Bases: MutableMapping[_KT, _VT]

Base class for all caches.

Parameters:

Name Type Description Default
max_size int

The maximum size of the cache.

 100

Attributes:

Name Type Description
_max_size int

The maximum size of the cache.
_cache Dict[_KT, _VT]

The cache itself.
_endpoints Dict[str, int]

The endpoints that are cached.
_endpoints_cached bool

Whether or not the endpoints are cached.
_client PokeLance

The client that this cache is for.

Examples:

Python Console Session
>>> import asyncio
>>> from pokelance import PokeLance
>>>
>>> async def main():
...     client = PokeLance()
...     print(await client.ping())
...     await asyncio.sleep(5)  # Wait for all the endpoints to load automatically. If not just load them manually.
...     # from pokelance.http import Endpoint
...     # data = await client.http.request(Endpoint.get_berry_endpoints())
...     # client.berry._cache.load_documents(str(client.berry.__class__.__name__).lower(), "berry", data)
...     # print(client.berry.cache.berry.endpoints)
...     # await client.berry.cache.berry.load_all(client.http)
...     print(client.berry.cache.berry)
...     await client.berry.cache.berry.save('temp')  # Save the cache to a file.
...     await client.berry.cache.berry.load('temp')  # Load the cache from a file.
...     print(client.berry.cache.berry)
...     await client.close()
>>>
>>> asyncio.run(main())
Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

BerryCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Berry']

A cache for berries.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

BerryFirmnessCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.BerryFirmness']

A cache for berry firmnesses.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

BerryFlavorCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.BerryFlavor']

A cache for berry flavors.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

CharacteristicCache(max_size=100) ⚓︎

Bases: SecondaryTypeCache['Route', 'models.Characteristic']

A cache for characteristics.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ContestEffectCache(max_size=100) ⚓︎

Bases: SecondaryTypeCache['Route', 'models.ContestEffect']

A cache for contest effects.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ContestTypeCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.ContestType']

A cache for contest types.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EggGroupCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.EggGroup']

A cache for egg groups.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EncounterConditionCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.EncounterCondition']

A cache for encounter conditions.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EncounterConditionValueCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.EncounterConditionValue']

A cache for encounter condition values.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EncounterMethodCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.EncounterMethod']

A cache for encounter methods.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EvolutionChainCache(max_size=100) ⚓︎

Bases: SecondaryTypeCache['Route', 'models.EvolutionChain']

A cache for evolution chains.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

EvolutionTriggerCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.EvolutionTrigger']

A cache for evolution triggers.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GamesGenerationCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Generation']

A cache for games generations.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GamesPokedexCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Pokedex']

A cache for games pokedexes.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GamesVersionCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Version']

A cache for games versions.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GamesVersionGroupCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.VersionGroup']

A cache for games version groups.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GenderCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Gender']

A cache for genders.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

GrowthRateCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.GrowthRate']

A cache for growth rates.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ItemAttributeCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.ItemAttribute']

A cache for item attributes.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ItemCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Item']

A cache for items.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ItemCategoryCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.ItemCategory']

A cache for item categories.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ItemFlingEffectCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.ItemFlingEffect']

A cache for item fling effects.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

ItemPocketCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.ItemPocket']

A cache for item pockets.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

LocationAreaCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.LocationArea']

A cache for location areas.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

LocationCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Location']

A cache for locations.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MachineCache(max_size=100) ⚓︎

Bases: SecondaryTypeCache['Route', 'models.Machine']

A cache for machines.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveAilmentCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveAilment']

A cache for move ailments.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveBattleStyleCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveBattleStyle']

A cache for move battle styles.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Move']

A cache for moves.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveCategoryCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveCategory']

A cache for move categories.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveDamageClassCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveDamageClass']

A cache for move damage classes.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveLearnMethodCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveLearnMethod']

A cache for move learn methods.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

MoveTargetCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.MoveTarget']

A cache for move targets.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

NatureCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Nature']

A cache for natures.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PalParkAreaCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PalParkArea']

A cache for pal park areas.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokeathlonStatCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokeathlonStat']

A cache for pokeathlon stats.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Pokemon']

A cache for pokemon.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonColorCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokemonColor']

A cache for pokemon colors.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonFormCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokemonForm']

A cache for pokemon forms.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonHabitatCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokemonHabitats']

A cache for pokemon habitats.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonLocationAreaCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.LocationAreaEncounter']

A cache for pokemon location areas.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonShapeCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokemonShape']

A cache for pokemon shapes.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

PokemonSpeciesCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.PokemonSpecies']

A cache for pokemon species.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

RegionCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Region']

A cache for regions.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

SecondaryTypeCache(max_size=100) ⚓︎

Bases: BaseCache[_KT, _VT]

A cache for secondary types with differing endpoints.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

StatCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Stat']

A cache for stats.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

SuperContestEffectCache(max_size=100) ⚓︎

Bases: SecondaryTypeCache['Route', 'models.SuperContestEffect']

A cache for super contest effects.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache. Endpoints are different for secondary types.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
346
347
348
349
350
351
352
353
354
355
356
357
358
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache. Endpoints are different for secondary types.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["url"].split("/")[-2]] = Endpoint(
            url=document["url"], id=int(document["url"].split("/")[-2])
        )
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)

TypeCache(max_size=100) ⚓︎

Bases: BaseCache['Route', 'models.Type']

A cache for types.

Source code in pokelance/cache/cache.py
Python
137
138
139
140
141
def __init__(self, max_size: int = 100) -> None:
    self._max_size = max_size
    self._cache: t.Dict[_KT, _VT] = {}
    self._endpoints: t.Dict[str, Endpoint] = {}
    self._endpoints_cached: bool = False

cache: t.Dict[_KT, _VT] property ⚓︎

The cache itself.

Returns:

Type Description
Dict[_KT, _VT]

The cache itself.

endpoints: t.Dict[str, Endpoint] property ⚓︎

The endpoints that are cached.

Returns:

Type Description
Dict[str, Endpoint]

The endpoints that are cached.

load(path='.') async ⚓︎

Load the cache from a file.

Parameters:

Name Type Description Default
path str

The path to load the cache from.

 '.'
Source code in pokelance/cache/cache.py
Python
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
async def load(self, path: str = ".") -> None:
    """Load the cache from a file.

    Parameters
    ----------
    path: str
        The path to load the cache from.
    """
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "r") as f:
        data = json.loads(await f.read())
    self._max_size = len(data)
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    for endpoint, info in data.items():
        route = route_model(endpoint=endpoint)
        self.setdefault(route, model.from_payload(info))

load_all() async ⚓︎

Load all documents/data from api into the cache. (Endpoints must be cached first)

Source code in pokelance/cache/cache.py
Python
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
async def load_all(self) -> None:
    """
    Load all documents/data from api into the cache. (Endpoints must be cached first)
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: "models.BaseModel" = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    for endpoint in self._endpoints.values():
        route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
        data = self.get(route, None)
        self.setdefault(route, data if data else model.from_payload(await self._client.http.request(route)))
    self._client.logger.info(f"Loaded {self.__class__.__name__}.")

load_all_batch(batch_size=20) async ⚓︎

Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

Parameters:

Name Type Description Default
batch_size int

The number of documents to load at once. Default is 20 to avoid overwhelming the API.

 20
Source code in pokelance/cache/cache.py
Python
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
async def load_all_batch(self, batch_size: int = 20) -> None:
    """
    Load all documents/data from api into the cache in parallel. (Endpoints must be cached first)

    Parameters
    ----------
    batch_size: int
        The number of documents to load at once. Default is 20 to avoid overwhelming the API.
    """
    if not self._endpoints_cached:
        raise RuntimeError("The endpoints have not been cached yet.")
    self._client.logger.info(f"Loading {self.__class__.__name__}...")
    route_model = importlib.import_module("pokelance.http").__dict__["Route"]
    value_type = str(self.__orig_bases__[0].__args__[1]).split(".")[-1]  # type: ignore
    model: t.Type["_VT"] = importlib.import_module("pokelance.models").__dict__[value_type]
    self._max_size = len(self._endpoints)
    endpoints = list(self._endpoints.values())
    total_endpoints = len(endpoints)
    for i in range(0, total_endpoints, batch_size):
        batch = endpoints[i : i + batch_size]
        tasks = []
        for endpoint in batch:
            route = route_model(endpoint=f"/{endpoint.url.strip('/').split('/')[-2]}/{str(endpoint)}")
            data = self.get(route, None)
            if data:
                self.setdefault(route, data)
                self._client.logger.info(f"Cached {route} - existing data used.")
            else:
                tasks.append(self._fetch_and_cache(route, model))
        if tasks:
            await asyncio.gather(*tasks)
        self._client.logger.debug(
            f"Loaded batch {i//batch_size + 1}/{(total_endpoints + batch_size - 1)//batch_size} for {self.__class__.__name__}"
        )
    self._client.logger.info(f"Loaded {self.__class__.__name__} - {len(self._cache)}/{total_endpoints} items.")

load_documents(data) ⚓︎

Load documents into the cache.

Parameters:

Name Type Description Default
data List[Dict[str, str]]

The data to load.

 required
Source code in pokelance/cache/cache.py
Python
195
196
197
198
199
200
201
202
203
204
205
def load_documents(self, data: t.List[t.Dict[str, str]]) -> None:
    """Load documents into the cache.

    Parameters
    ----------
    data: typing.List[typing.Dict[str, str]]
        The data to load.
    """
    for document in data:
        self._endpoints[document["name"]] = Endpoint(url=document["url"], id=int(document["url"].split("/")[-2]))
    self._endpoints_cached = True

save(path='.') async ⚓︎

Save the cache to a file.

Parameters:

Name Type Description Default
path str

The path to save the cache to.

 '.'
Source code in pokelance/cache/cache.py
Python
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
async def save(self, path: str = ".") -> None:
    """Save the cache to a file.

    Parameters
    ----------
    path: str
        The path to save the cache to.
    """
    pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    dummy: t.Dict[str, t.Dict[str, t.Any]] = {k.endpoint: v.raw for k, v in self.items()}
    async with aiofiles.open(pathlib.Path(f"{path}/{self.__class__.__name__}.json"), "w") as f:
        await f.write("{\n")
        for n, (k, v) in enumerate(dummy.items()):
            await f.write("\n".join([4 * " " + i for i in f'"{k}": {json.dumps(v, indent=4)}'.split("\n")]))
            if n != len(dummy) - 1:
                await f.write(",\n")
        await f.write("\n}")

set_size(size) ⚓︎

Set the size of the cache.

Parameters:

Name Type Description Default
size int

The size of the cache.

 required
Source code in pokelance/cache/cache.py
Python
207
208
209
210
211
212
213
214
215
def set_size(self, size: int) -> None:
    """Set the size of the cache.

    Parameters
    ----------
    size: int
        The size of the cache.
    """
    self._max_size = size

wait_until_ready() async ⚓︎

Wait until the all the endpoints are cached.

Source code in pokelance/cache/cache.py
Python
217
218
219
220
221
async def wait_until_ready(self) -> None:
    """Wait until the all the endpoints are cached."""
    await self._client.http.connect()
    while not self._endpoints_cached and self._client.cache_endpoints:
        await asyncio.sleep(0.5)