libsocial-core API reference
import libsocial. Most users get these through ranobelib or mangalib, which re-export
the models and exceptions — see libsocial-core.
Building blocks
libsocial.Site
classSite(id: int, origin: str)One lib.social site, as the shared api.cdnlibs.org API tells them apart.
The core knows no site by itself: each site package defines its own (ranobelib.me is
Site(id=3, origin="https://ranobelib.me"), mangalib.me id=1) and passes it in.
| Name | Type | Description |
|---|---|---|
id | int | The site's id — sent as the |
origin | str | The site's web origin, e.g. |
libsocial.TitleClient
classTitleClient(
url: str,
*,
cache_dir: str | Path | None = None,
cache_ttl: float | None = None,
verbosity: Verbosity = False,
headers: Mapping[str, str] | None = None,
) Generic[TitleT, ChapterT, VolumeT]
One title on one lib.social site: metadata, chapters, translations, bulk download.
Not used directly: a site package subclasses it, setting the class attributes below — which site it talks to, and which models a title, a chapter (with the site's own content fields) and a volume are validated as — and adds whatever is specific to the site's content (export, size estimates, ...).
| Name | Type | Description |
|---|---|---|
site | Site | The site the title is on. Set by the subclass. |
title_model | type[TitleT] | The model |
chapter_model | type[ChapterT] | The model chapters are validated as — both table-of-contents entries and fetched chapters, so its content fields must be optional. Set by the subclass. |
volume_model | type[VolumeT] | The model chapters are grouped into, |
default_cache_dir | Path |
|
info_fields | tuple[str, ...] | Extra |
slug_url
attributepropertyslug_url: strThe title's {id}--{slug} identifier.
aclose
methodasyncaclose() -> NoneClose the underlying HTTP client.
SOURCE ↗download_title
methodasyncdownload_title(
*,
branch_id: int | None = None,
translation_index: int | None = None,
chapter_delay: float = 0.0,
on_chapter: Callable[[int, int], None] | None = None,
max_rate_limit_retries: int = DEFAULT_RATE_LIMIT_RETRIES,
) -> list[VolumeT]Download every chapter of the title, across all its volumes.
Fetches the chapter list once, then every chapter's content, sequentially, in the
API's own order — same pacing/retry/backoff as any other chapter fetch (see
ApiClient), plus chapter_delay on top if given.
Resolving translations is checked for the whole title up front, not chapter by
chapter: if any chapters have more than one translation, this fetches nothing and
raises MultipleTitleTranslationsError listing all of them at once (unless
branch_id or translation_index resolves every one of them), rather than
failing partway through a long download on the first ambiguous chapter.
A long title's sequential download can outlast ApiClient's own retry budget for
429s (tuned for a single one-off request, not hundreds/thousands of sequential
fetches — see docs/api-notes.md). On top of that, each chapter fetch that still comes
back rate-limited is retried again here, up to max_rate_limit_retries times, with
its own (coarser) backoff. If a chapter fetch still fails after that — from rate
limiting or anything else — the chapters already downloaded are not discarded: they're
attached to a raised DownloadTitleInterruptedError instead of being lost.
| Name | Type | Description | Default |
|---|---|---|---|
branch_id | int | None | Translation to use for every chapter that has more than one — same
meaning as | None |
translation_index | int | None | Alternative to | None |
chapter_delay | float | Extra delay, in seconds, after fetching each chapter, on top of
| 0.0 |
on_chapter | Callable[[int, int], None] | None | Called with | None |
max_rate_limit_retries | int | How many extra times to retry a single chapter fetch that
comes back rate-limited, on top of | DEFAULT_RATE_LIMIT_RETRIES |
| Type | Description |
|---|---|
ValueError | If both |
MultipleTitleTranslationsError | If the title has one or more chapters with more
than one translation that |
DownloadTitleInterruptedError | If fetching a chapter fails unrecoverably partway through the download — carries every chapter already fetched. |
get_chapter
methodasyncget_chapter(
volume: int,
number: str,
*,
branch_id: int | None = None,
refresh: bool = False,
) -> ChapterTFetch a single chapter, including its content.
When a chapter has more than one team's translation and branch_id isn't given,
this raises MultipleTranslationsError rather than guessing — see
get_translations() and docs/api-notes.md for why the API's own default (when
branch_id is omitted) isn't relied on. Doing this check costs an extra request
to fetch the chapter list, only when branch_id isn't already given.
| Name | Type | Description | Default |
|---|---|---|---|
volume | int | The chapter's volume number. | |
number | str | The chapter number, as returned by the API — may contain a decimal
(e.g. | |
branch_id | int | None | Which translation to fetch, as returned by | None |
refresh | bool | Bypass the disk cache and re-fetch from the API even if a cached response is on hand. | False |
| Type | Description |
|---|---|
MultipleTranslationsError | If the chapter has more than one translation and
|
get_chapters
methodasyncget_chapters(chapters: list[tuple[int, str]]) -> list[ChapterT]Fetch several chapters, including their content.
Fetches the chapter list once, shared across all requested chapters (also used to
detect chapters with more than one translation — see get_chapter), then each
chapter individually and sequentially, in the order given.
| Name | Type | Description |
|---|---|---|
chapters | list[tuple[int, str]] | A list of |
| Type | Description |
|---|---|
ChapterNotFoundError | If any requested chapter doesn't exist. |
MultipleTranslationsError | If any requested chapter has more than one translation. |
get_info
methodasyncget_info(*, refresh: bool = False) -> TitleTFetch title metadata: names, cover, summary, genres, tags, authors, teams.
| Name | Type | Description | Default |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if a cached response is on hand. | False |
get_table_of_contents
methodasyncget_table_of_contents(*, refresh: bool = False) -> list[VolumeT]Fetch the title's volumes and chapter names/numbers, without chapter content.
| Name | Type | Description | Default |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if a cached response is on hand — needed to pick up newly published chapters, since otherwise the cached chapter list would keep being reused. | False |
get_translations
methodasyncget_translations(volume: int, number: str) -> list[ChapterBranch]Fetch the available translations (branches) for a chapter.
| Name | Type | Description |
|---|---|---|
volume | int | The chapter's volume number. |
number | str | The chapter number. |
| Type | Description |
|---|---|
ChapterNotFoundError | If no chapter exists for this volume/number. |
get_volume
methodasyncget_volume(volume: int) -> VolumeTFetch a whole volume: all its chapters, each including content.
The API has no bulk "volume content" endpoint (see docs/api-notes.md), so this fetches the chapter list once to find which numbers belong to the volume, then fetches each of those chapters individually and sequentially.
| Name | Type | Description |
|---|---|---|
volume | int | The volume number. |
| Type | Description |
|---|---|
VolumeNotFoundError | If the title has no chapters for this volume. |
MultipleTranslationsError | If any of the volume's chapters has more than one translation. |
get_volumes
methodasyncget_volumes(volumes: list[int]) -> list[VolumeT]Fetch several whole volumes, each including chapter content.
Fetches the chapter list once, shared across all requested volumes, then each
chapter individually and sequentially — same approach as get_volume, applied
to more than one volume without re-fetching the chapter list per volume.
| Name | Type | Description |
|---|---|---|
volumes | list[int] | The volume numbers to fetch. |
| Type | Description |
|---|---|
VolumeNotFoundError | If the title has no chapters for one of the volumes. |
MultipleTranslationsError | If any of the volumes' chapters has more than one translation. |
libsocial.Catalog
classCatalog(
*,
cache_dir: str | Path | None = None,
cache_ttl: float | None = None,
headers: Mapping[str, str] | None = None,
) Generic[TitleT]
Listing/searching one site's catalog.
Not used directly: a site package subclasses it, setting site and page_model
(and optionally default_cache_dir) as class attributes — so its own Catalog
keeps a plain constructor and returns its own page and Title models.
| Name | Type | Description |
|---|---|---|
site | Site | The site whose catalog is listed. Set by the subclass. |
page_model | type[CatalogPage[TitleT]] | The model a listing page is validated as — |
default_cache_dir | Path |
|
aclose
methodasyncaclose() -> NoneClose the underlying HTTP client.
SOURCE ↗list_countries
methodasynclist_countries(*, refresh: bool = False) -> list[Country]Fetch the full list of catalog countries (id → name), for use as filter options
with list_titles(countries=...).
Mirrors list_genres() exactly, down to the network-wide, not-site-scoped shape
of the underlying endpoint (GET /api/constants?fields[]=types — the API's own
name for what this SDK calls "country" is "type", see docs/api-notes.md and
Country's docstring). This filters that down to entries tagged for site before
returning, same as list_genres() does for genres.
| Name | Type | Description | Default |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the country list was already cached. | False |
| Type | Description |
|---|---|
list[Country] | Every |
list_genres
methodasynclist_genres(*, refresh: bool = False) -> list[Genre]Fetch the full list of catalog genres (id → name), for use as filter options
with list_titles(genres=[...]).
The underlying endpoint (GET /api/constants?fields[]=genres) has no site-scoping
parameter — it returns the full genre list shared across the whole lib.social
network in one shot, each tagged with the site ids it applies to (see
docs/api-notes.md). This filters that down to genres tagged for site before
returning, so callers don't get filter options that could never match any of the
site's titles (e.g. "Детское", tagged only for site 5, on ranobelib.me).
| Name | Type | Description | Default |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the genre list was already cached. | False |
| Type | Description |
|---|---|
list[Genre] | Every |
list_statuses
methodasynclist_statuses(*, refresh: bool = False) -> list[Label]Fetch the full list of title statuses (id → label), for use as filter options
with list_titles(statuses=...).
Mirrors list_genres()/list_countries(): the underlying endpoint
(GET /api/constants?fields[]=status) isn't site-scoped, so entries not tagged for
site are dropped before returning (see docs/api-notes.md). Returns the same
Label model as Title.status, so a title's status can be compared against
these directly.
| Name | Type | Description | Default |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the status list was already cached. | False |
| Type | Description |
|---|---|
list[Label] | Every status ( |
list_titles
methodasynclist_titles(
*,
page: int = 1,
per_page: int = 30,
query: str | None = None,
genres: list[int] | None = None,
tags: list[int] | None = None,
statuses: list[int] | None = None,
countries: list[int] | None = None,
min_chapters: int | None = None,
max_chapters: int | None = None,
sort: str = DEFAULT_SORT,
refresh: bool = False,
) -> CatalogPage[TitleT]Fetch one page of catalog listing/search results.
| Name | Type | Description | Default |
|---|---|---|---|
page | int | 1-based page number. | 1 |
per_page | int | How many titles per page. Must be between | 30 |
query | str | None | Free-text search term, matched against name/rus_name/eng_name. | None |
genres | list[int] | None | Genre ids to filter by. A title must have all of them, not just one
(AND, not OR — see docs/api-notes.md). Not validated against | None |
tags | list[int] | None |
| None |
statuses | list[int] | None |
| None |
countries | list[int] | None |
| None |
min_chapters | int | None | Only titles with at least this many chapters (inclusive). Counts
the same number as | None |
max_chapters | int | None | Only titles with at most this many chapters (inclusive). | None |
sort | str | Sort order. Despite the name, this is sent as the API's | DEFAULT_SORT |
refresh | bool | Bypass the disk cache and re-fetch from the API even if this exact combination of parameters was already cached. | False |
| Type | Description |
|---|---|
CatalogPage[TitleT] | A |
| Type | Description |
|---|---|
ValueError | If |
libsocial.ApiClient
classApiClient(
site: Site,
*,
base_url: str = API_BASE_URL,
timeout: float = 15.0,
transport: httpx.AsyncBaseTransport | None = None,
headers: Mapping[str, str] | None = None,
max_concurrency: int = 5,
request_delay: float | None = None,
max_retries: int = 3,
retry_base_delay: float = 1.0,
sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
pacer: Pacer | None = None,
)Thin async wrapper around the undocumented api.cdnlibs.org JSON API, for one site.
The API is shared by the whole lib.social network; site scopes requests to one site
(Site-Id header, site_id[] on catalog listings — see docs/api-notes.md).
Bounds concurrency with a semaphore, paces request starts with a small fixed delay, and
retries 429/5xx responses with exponential backoff — see docs/api-notes.md for why a
manual implementation was chosen over a dependency like tenacity for this. Pacing is
shared, by default, with every other ApiClient in the process talking to the same
host (see Pacer), so clients for different sites don't add up their request rates.
Every request carries browser-like Origin/Referer/User-Agent headers on top
of the API-specific Site-Id/Accept: without a non-empty Referer, the
DDoS-Guard edge in front of the API answers every request with an HTML 403 page (see
docs/api-notes.md, section "WAF 403").
| Name | Type | Description |
|---|---|---|
headers_hint | str | Where |
aclose
methodasyncaclose() -> NoneClose the underlying HTTP connection pool.
SOURCE ↗get_chapter
methodasyncget_chapter(
slug_url: str,
*,
number: str,
volume: str,
branch_id: int | None = None,
) -> dict[str, Any]Fetch a single chapter's metadata and content.
| Name | Type | Description | Default |
|---|---|---|---|
slug_url | str | The title's | |
number | str | The chapter number, as returned by the API (may contain a decimal). | |
volume | str | The volume number. | |
branch_id | int | None | Which translation team's branch to fetch, for chapters with more than one. Defaults to whichever branch the API picks (see docs/api-notes.md — this is not simply the first branch listed). | None |
| Type | Description |
|---|---|
dict[str, Any] | The |
get_chapters
methodasyncget_chapters(slug_url: str) -> list[dict[str, Any]]Fetch the raw chapter list for slug_url (single request, no pagination).
| Name | Type | Description |
|---|---|---|
slug_url | str | The title's |
| Type | Description |
|---|---|
list[dict[str, Any]] | The |
get_title
methodasyncget_title(
slug_url: str,
*,
fields: list[str] | None = None,
) -> dict[str, Any]Fetch raw title metadata for slug_url.
| Name | Type | Description | Default |
|---|---|---|---|
slug_url | str | The title's | |
fields | list[str] | None | Extra | None |
| Type | Description |
|---|---|
dict[str, Any] | The |
list_countries
methodasynclist_countries() -> list[dict[str, Any]]Fetch the raw country/type list shared across the whole lib.social network.
Same shape and caveats as list_genres: not site-scoped by any request parameter,
returns every "type" known to the network at once, each tagged with the site ids it
applies to via site_ids. Named list_countries/fields[]=types mismatch is
deliberate — see Catalog.list_countries and docs/api-notes.md for why this reuses
the API's own "type" concept rather than the unrelated fields[]=countries field.
| Type | Description |
|---|---|
list[dict[str, Any]] | The raw |
list_genres
methodasynclist_genres() -> list[dict[str, Any]]Fetch the raw genre list shared across the whole lib.social network.
Unlike list_titles, this endpoint isn't site-scoped by any request parameter
(confirmed: a Site-Id header changes nothing about the response) — it returns
every genre known to the network at once, each tagged with the site ids it applies
to via a site_ids field. Callers must filter to their site themselves (see
Catalog.list_genres, which drops e.g. site-5-only genres like "Детское" when
listing for ranobelib.me).
| Type | Description |
|---|---|
list[dict[str, Any]] | The raw |
list_statuses
methodasynclist_statuses() -> list[dict[str, Any]]Fetch the raw title status list shared across the whole lib.social network.
Same shape and caveats as list_genres: not site-scoped by any request parameter,
returns every status known to the network at once, each tagged with the site ids it
applies to via site_ids.
| Type | Description |
|---|---|
list[dict[str, Any]] | The raw |
list_titles
methodasynclist_titles(
*,
page: int,
per_page: int,
query: str | None,
genres: list[int] | None,
tags: list[int] | None,
statuses: list[int] | None,
countries: list[int] | None,
min_chapters: int | None,
max_chapters: int | None,
sort: str,
) -> dict[str, Any]Fetch one page of the catalog listing/search results.
Unlike the other ApiClient methods, this returns the whole response body, not
just data — callers need meta.has_next_page too, and there's no total count
to derive it from otherwise (see docs/api-notes.md).
| Name | Type | Description |
|---|---|---|
page | int | 1-based page number. |
per_page | int | Page size. The API only accepts |
query | str | None | Free-text search term, matched against name/rus_name/eng_name. |
genres | list[int] | None | Genre ids to filter by. A title must have all of them (AND, not OR — see docs/api-notes.md), not just any one. |
tags | list[int] | None | Tag ids to filter by. Same AND semantics as |
statuses | list[int] | None |
|
countries | list[int] | None |
|
min_chapters | int | None | Minimum chapter count, inclusive. Sent as |
max_chapters | int | None | Maximum chapter count, inclusive. Sent as |
sort | str | Forwarded as the API's |
| Type | Description |
|---|---|
dict[str, Any] | The full JSON response: |
libsocial.Pacer
classPacer(*, clock: Callable[[], float] = time.monotonic)Spaces out request starts: each one at least its delay after the previous one.
Every ApiClient talking to the same host shares one Pacer by default (see
shared_pacer()), so two clients for different sites in one process — say ranobelib
and mangalib, both on api.cdnlibs.org — pace against each other instead of each sending
at its own full rate and doubling the load on the API between them.
Works by reservation: a caller takes the next free start slot under a plain
threading.Lock, held only for that bookkeeping and never across an await, then
sleeps until the slot outside of it. So a single Pacer is safe to share across event
loops and threads, which an asyncio.Lock (bound to the loop that first used it) is
not.
wait
methodasyncwait(delay: float, *, sleep: Callable[[float], Awaitable[None]]) -> NoneWait for this request's start slot, and reserve delay seconds after it.
| Name | Type | Description |
|---|---|---|
delay | float | Minimum time, in seconds, before the next request (from any client sharing this pacer) may start after this one. Each caller passes its own, so clients with different delays can share a pacer. |
sleep | Callable[[float], Awaitable[None]] | Sleep function to wait with — the calling client's, so tests that inject a fake one don't actually wait. |
libsocial.shared_pacer
functionshared_pacer(host: str) -> PacerThe process-wide Pacer for host, created on first use.
| Name | Type | Description |
|---|---|---|
host | str | The API host, e.g. |
libsocial.PlannedChapter
classPlannedChapter() NamedTuple
A chapter a bulk operation will fetch, with the translation to fetch it in.
| Name | Type | Description |
|---|---|---|
volume | str | The chapter's volume number. |
number | str | The chapter number. |
branch_id | int | None | The branch to request, or |
Models
libsocial.Title
classTitle() BaseModel
Metadata for a single title.
SOURCE ↗chapter_count
attributechapter_count: int | None = NoneNumber of uploaded chapters. Only TitleClient.get_info() fills it in: the catalog
listing endpoint doesn't return it (see docs/api-notes.md), so it's None on
Catalog.list_titles() items.
last_chapter_at
attributelast_chapter_at: datetime | None = Field(default=None, alias='last_item_at')When the most recent chapter was published — the value the catalog's
sort="last_chapter_at" orders by. Only TitleClient.get_info() fills it in: the
catalog listing endpoint doesn't return it (see docs/api-notes.md), so it's None on
Catalog.list_titles() items, and on a title with no chapters yet.
libsocial.Chapter
classChapter() BaseModel
A chapter: volume, number, name and available translations — not its content.
index/item_number/branches_count/branches come from the chapter-list
endpoint (see TitleClient.get_table_of_contents()) and are None/empty when a
Chapter instead comes from fetching a single chapter, which has a different response
shape (see docs/api-notes.md). What the chapter contains is site-specific: a site
package subclasses this with its content fields and parsing.
libsocial.ChapterBranch
classChapterBranch() BaseModel
A single team's (or solo uploader's) translation of a chapter.
A chapter has more than one branch when several teams have translated it
independently; see Chapter.branches_count.
libsocial.Volume
classVolume() BaseModel, Generic[ChapterT]
A volume: its number and the chapters it contains, in title order.
Generic over the chapter model — a site package uses Volume[ItsChapter] (or a
subclass of it) so its chapters keep their content fields.
libsocial.CatalogPage
classCatalogPage() BaseModel, Generic[TitleT]
One page of catalog listing/search results, as returned by Catalog.list_titles().
items reuses the title model as-is — a catalog list item has every field Title
requires, the ones it doesn't send (genres, summary, chapter_count,
last_chapter_at, ...) just come back at their defaults, same as any other
partially-populated Title (see docs/api-notes.md).
Exceptions
libsocial.LibSocialError
classLibSocialError() Exception
Base class for all errors raised by libsocial-core and the site SDKs built on it.
SOURCE ↗libsocial.TitleNotFoundError
classTitleNotFoundError(slug_url: str)Raised when a title cannot be found on the site.
| Name | Type | Description |
|---|---|---|
slug_url | The title's |
libsocial.ChapterNotFoundError
classChapterNotFoundError(slug_url: str, *, volume: str, number: str)Raised when a chapter cannot be found for a given volume/number.
| Name | Type | Description |
|---|---|---|
slug_url | The title's | |
volume | The volume number that was requested. | |
number | The chapter number that was requested. |
libsocial.VolumeNotFoundError
classVolumeNotFoundError(slug_url: str, *, volume: str)Raised when a title has no chapters for a given volume number.
| Name | Type | Description |
|---|---|---|
slug_url | The title's | |
volume | The volume number that was requested. |
libsocial.MultipleTranslationsError
classMultipleTranslationsError(
slug_url: str,
*,
volume: str,
number: str,
branches: list[ChapterBranch],
)Raised when a chapter has more than one team's translation and none was selected.
The SDK does not guess a default: the API's own default when branch_id is omitted
is not simply the first branch listed, and the actual rule it uses isn't documented
(see docs/api-notes.md) — returning it silently would be unpredictable. Call
TitleClient.get_translations() to list the available branches, then pass one's
branch_id explicitly.
| Name | Type | Description |
|---|---|---|
slug_url | The title's | |
volume | The chapter's volume number. | |
number | The chapter number. | |
branches | The chapter's available translations, as returned by
|
libsocial.MultipleTitleTranslationsError
classMultipleTitleTranslationsError(
slug_url: str,
*,
chapters: list[AmbiguousChapter],
)Raised by download_title() when one or more chapters have an unresolved translation.
Unlike MultipleTranslationsError (one chapter), this can list several: a title-wide
bulk download checks every chapter up front rather than stopping at the first ambiguous
one, so a caller doesn't have to fix one chapter, rerun, hit the next, and rerun again.
Pass branch_id or translation_index to download_title() to resolve them, or
fetch the listed chapters individually with get_chapter(..., branch_id=...).
| Name | Type | Description |
|---|---|---|
slug_url | The title's | |
chapters | The ambiguous chapters and their available translations. |
libsocial.AuthRequiredError
classAuthRequiredError(url: str)Raised when the requested content requires authorization (paid or early access).
| Name | Type | Description |
|---|---|---|
url | The request URL that returned 403. |
libsocial.AccessBlockedError
classAccessBlockedError(
url: str,
*,
headers_hint: str = DEFAULT_HEADERS_HINT,
)Raised when the site's edge protection rejects a request before it reaches the API.
Not an authorization problem, unlike AuthRequiredError: the DDoS-Guard edge in front
of api.cdnlibs.org answers with an HTML 403 page (the API's own 403 is JSON) when it
doesn't like the request — so far, a missing or empty Referer (see
docs/api-notes.md, section "WAF 403"). The SDK already sends browser-like headers, so
seeing this means either the edge changed its rules — check for an SDK update, or send
what it now expects via headers= on the title client/Catalog (or ApiClient,
if using it directly) — or the edge is blocking the network/IP itself, which no header
fixes. Not retried: resending the same request gets the same answer.
| Name | Type | Description |
|---|---|---|
url | The request URL that returned 403. |
libsocial.RateLimitError
classRateLimitError(retry_after: float | None = None)Raised when the API responds with 429 Too Many Requests.
| Name | Type | Description |
|---|---|---|
retry_after | The response's |
libsocial.DownloadTitleInterruptedError
classDownloadTitleInterruptedError(
slug_url: str,
*,
volumes: Sequence[Volume[Any]],
completed: int,
total: int,
)Raised by download_title() when a chapter fetch fails unrecoverably partway through.
download_title() fetches hundreds-to-thousands of chapters sequentially for a long
title, which can outlast even the extra, bulk-specific rate-limit retry budget described
in download_title()'s max_rate_limit_retries — or hit some other unrecoverable
error (e.g. AuthRequiredError on a chapter that turns out to need a paywall/auth
token). Rather than letting that error propagate on its own and silently discard every
chapter already fetched, it's wrapped in this exception instead, carrying what was
already downloaded — so a caller can keep that partial result, or simply call
download_title() again: the SDK's disk cache means already-fetched chapters aren't
re-requested, so a retry resumes close to where this one stopped rather than restarting
the whole title. See docs/api-notes.md's "Rate limiting и retry" section and issue #41.
| Name | Type | Description |
|---|---|---|
slug_url | The title's | |
volumes | list[Volume[Any]] | Chapters fetched before the failure, grouped into volumes the same way a
successful |
completed | How many chapters were fetched before the failure. | |
total | How many chapters |
Cache maintenance
libsocial.cache_stats
functioncache_stats(cache_dir: str | Path = DEFAULT_CACHE_DIR) -> CacheStatsCount the entries in a disk cache and their total size on disk.
Only files the cache itself writes are counted, not anything else that happens to be in the directory.
| Name | Type | Description | Default |
|---|---|---|---|
cache_dir | str | Path | The cache directory — the same | DEFAULT_CACHE_DIR |
| Type | Description |
|---|---|
CacheStats | The number of entries and their total size in bytes. A missing directory is an empty |
CacheStats | cache, |
libsocial.clear_cache
functionclear_cache(
cache_dir: str | Path = DEFAULT_CACHE_DIR,
*,
older_than: float | None = None,
) -> CacheStatsRemove entries from a disk cache.
Only files the cache itself writes are removed — anything else in the directory, and the directory itself, is left alone. Safe to call while clients are using the same cache: an entry being read as it's removed is just a cache miss, and one written after it's removed is simply recreated.
| Name | Type | Description | Default |
|---|---|---|---|
cache_dir | str | Path | The cache directory — see | DEFAULT_CACHE_DIR |
older_than | float | None | If given, only remove entries written more than this many seconds ago
(the same age check | None |
| Type | Description |
|---|---|
CacheStats | The number of entries removed and the bytes they took. A missing directory removes |
CacheStats | nothing, |
| Type | Description |
|---|---|
ValueError | If |
libsocial.CacheStats
classCacheStats(entries: int, bytes: int)How many cache entries there are (or were removed), and their total size on disk.
SOURCE ↗