ranobelib API reference
Entry point
ranobelib.RanobeLib
classRanobeLib(
url: str,
*,
cache_dir: str | Path | None = None,
cache_ttl: float | None = None,
verbosity: Verbosity = False,
headers: Mapping[str, str] | None = None,
) TitleClient[Title, Chapter, Volume]
Entry point for interacting with a single ranobelib.me title.
SOURCE ↗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. |
estimate_title_size
methodasyncestimate_title_size(
*,
sample_size: int = DEFAULT_SAMPLE_SIZE,
average_image_size: int = DEFAULT_AVERAGE_IMAGE_SIZE,
branch_id: int | None = None,
translation_index: int | None = None,
) -> intEstimate the whole title's download size in bytes, from a sample of its chapters.
Fetches the chapter list (cheap, cached), then the content of up to sample_size
chapters spread evenly across the title — not just the first ones, since early and
late chapters can differ in length — and extrapolates the sample's average
sizing.chapter_size() across the title's total chapter count. This trades
exactness for cost: an exact total requires fetching every chapter's content, the
same cost as download_title() itself, which defeats the purpose of checking
"is this worth downloading" before paying that cost.
Sampled chapters go through the same disk cache as any other chapter fetch, so a
later download_title() call doesn't refetch them.
| Name | Type | Description | Default |
|---|---|---|---|
sample_size | int | How many chapters to sample. Clamped to the number of chapters the title actually has (or that resolve to a usable translation, see below) if that's fewer. | DEFAULT_SAMPLE_SIZE |
average_image_size | int | Forwarded to | DEFAULT_AVERAGE_IMAGE_SIZE |
branch_id | int | None | Same meaning as | None |
translation_index | int | None | Same meaning as | None |
| Type | Description |
|---|---|
int | The estimated size in bytes, or |
int | its chapters have a translation |
| Type | Description |
|---|---|
ValueError | If both |
export
methodasyncexport(chapters: list[Chapter], *, fmt: str, path: str | Path) -> PathExport chapters to a file.
| Name | Type | Description |
|---|---|---|
chapters | list[Chapter] | The chapters to include, in the order they should appear. |
path | str | Path | Where to write the exported file. |
fmt | str | Export format — a key of |
| Type | Description |
|---|---|
ValueError | If |
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. |
ranobelib.Catalog
classCatalog(
*,
cache_dir: str | Path | None = None,
cache_ttl: float | None = None,
headers: Mapping[str, str] | None = None,
)Entry point for listing/searching the ranobelib.me catalog.
Lists titles (list_titles()) and the filter options for them (list_genres(),
list_countries(), list_statuses()), each filtered to ranobelib.me.
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 |
Models
ranobelib.CatalogPage
classCatalogPage() _core.CatalogPage[Title]
One page of catalog listing/search results, as returned by Catalog.list_titles().
items reuses Title 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).
ranobelib.Title
classTitle() _core.Title
Metadata for a single title (novel).
SOURCE ↗base_names
attributepropertybase_names: list[str]The title's names without the format suffix ranobelib.me appends to them.
rus_name, eng_name, name and other_names, in that order, each with
trailing publication-format markers removed — "Старшая школа D×D (Новелла)" →
"Старшая школа D×D", likewise (Novel), (LN), (WN), (Light Novel),
(Ранобэ), [квест], ... (stacked ones too, (LN) (Novel)). Other bracketed
tails — a year, (18+), (Фанфик), [LitRPG], a franchise name — distinguish
one title from another and are kept. Whitespace is trimmed; empty names and
duplicates (keeping the first) are dropped. Nothing else is normalized (case,
punctuation, ×): that's up to whatever compares the names.
The original fields are left as they are. On Catalog.list_titles() items
other_names is empty (the listing doesn't return it), so it contributes nothing.
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.
ranobelib.Chapter
classChapter() _core.Chapter
A chapter: volume, number, name, available translations, and optionally its content.
index/item_number/branches_count/branches come from the chapter-list
endpoint (see RanobeLib.get_table_of_contents()) and are None/empty when a
Chapter instead comes from fetching a single chapter's content, which has a
different response shape (see docs/api-notes.md). content is the reverse: only
populated by the single-chapter endpoint.
footnotes holds the chapter's translator footnotes (see Footnote), which are
removed from content rather than kept in both places — empty when the chapter has
none, or when content isn't fetched.
ranobelib.Footnote
classFootnote() BaseModel
A translator footnote (term explanation, translation note) taken out of a chapter.
The API has no structured footnotes (see docs/api-notes.md): they're ordinary
paragraphs/list items whose text starts with ↑, so that arrow is what the SDK detects
them by — and strips from content. There's no marker linking a footnote back to a
point in the text: translators mark the reference with an unnumbered * at best, which
the text also uses for scene breaks and censored words, so Chapter.footnotes's order
(the order they appear in the source) is the only link there is.
content
attributecontent: strSanitized inline HTML (same tag vocabulary as Chapter.content), without the arrow
and without a wrapping <p>.
ranobelib.Volume
classVolume()A volume: its number and the chapters it contains, in title order.
SOURCE ↗ranobelib.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.
ranobelib.Genre
classGenre() BaseModel
A genre tag (e.g. Fantasy, Romance).
SOURCE ↗ranobelib.Country
classCountry() BaseModel
A title's country/region of origin.
Maps onto what the raw API itself calls "type" (Title's raw type field; the
catalog filter's types[] parameter; GET /api/constants?fields[]=types) — not a
country/countries[]/fields[]=countries concept, which turned out to be
something unrelated (see docs/api-notes.md). The values aren't all literal countries: on
ranobelib.me, Japan, Korea and China sit next to original English-language work, original
web novel and fanfiction, all surfaced as-is.
ranobelib.Label
classLabel() BaseModel
A small {id, label} enum value used throughout the API (status, age rating, ...).
Exceptions
ranobelib.RanobeLibError
attributeRanobeLibError = LibSocialErrorBase class for all errors raised by the SDK (libsocial.LibSocialError).
ranobelib.TitleNotFoundError
classTitleNotFoundError(slug_url: str)Raised when a title cannot be found on the site.
| Name | Type | Description |
|---|---|---|
slug_url | The title's |
ranobelib.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. |
ranobelib.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. |
ranobelib.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
|
ranobelib.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. |
ranobelib.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. |
ranobelib.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. |
ranobelib.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 |
ranobelib.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
ranobelib.cache_stats
functioncache_stats(cache_dir: str | Path = DEFAULT_CACHE_DIR) -> CacheStatsCount the entries in an SDK 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, |
ranobelib.clear_cache
functionclear_cache(
cache_dir: str | Path = DEFAULT_CACHE_DIR,
*,
older_than: float | None = None,
) -> CacheStatsRemove entries from an SDK 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 |
ranobelib.CacheStats
classCacheStats(entries: int, bytes: int)How many cache entries there are (or were removed), and their total size on disk.
SOURCE ↗Sizing
ranobelib.chapter_size
functionchapter_size(
chapter: Chapter,
*,
average_image_size: int = DEFAULT_AVERAGE_IMAGE_SIZE,
) -> intEstimate a fetched chapter's size in bytes: exact text plus assumed-average images.
| Name | Type | Description | Default |
|---|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via | |
average_image_size | int | Assumed bytes per | DEFAULT_AVERAGE_IMAGE_SIZE |
| Type | Description |
|---|---|
ValueError | If |
ranobelib.volume_size
functionvolume_size(
volume: Volume,
*,
average_image_size: int = DEFAULT_AVERAGE_IMAGE_SIZE,
) -> intEstimate a fetched volume's size in bytes: the sum of its chapters' chapter_size().
| Name | Type | Description | Default |
|---|---|---|---|
volume | Volume | A volume whose chapters have content already fetched (e.g. via
| |
average_image_size | int | Forwarded to | DEFAULT_AVERAGE_IMAGE_SIZE |
| Type | Description |
|---|---|
ValueError | If any chapter in |
Chapter content
ranobelib.chapter_image_urls
functionchapter_image_urls(chapter: Chapter) -> list[str]List the image URLs a fetched chapter references.
| Name | Type | Description |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
| Type | Description |
|---|---|
list[str] | Every |
list[str] | document order, each URL listed once (its first occurrence). |
| Type | Description |
|---|---|
ValueError | If |
ranobelib.rewrite_image_urls
functionrewrite_image_urls(
chapter: Chapter,
replace: Callable[[str], str],
) -> ChapterReturn a copy of a fetched chapter with every <img src> passed through replace.
| Name | Type | Description |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
replace | Callable[[str], str] | Called with each image URL (once per |
| Type | Description |
|---|---|
ValueError | If |
ranobelib.chapter_paragraphs
functionchapter_paragraphs(chapter: Chapter) -> list[str]A fetched chapter's top-level blocks as plain text, in document order.
Entry i is the text of the i-th top-level element of chapter.content — the
same position a browser gives it among the rendered content's element children — so a
paragraph index counted in the DOM can be used to look it up directly.
| Name | Type | Description |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
| Type | Description |
|---|---|
list[str] | One string per top-level element: its text with entities decoded and whitespace |
list[str] | collapsed to single spaces ( |
list[str] | an image-only paragraph). |
list[str] | of |
| Type | Description |
|---|---|
ValueError | If |
Exporters
Not re-exported from the top-level ranobelib package — import from ranobelib.exporters.
Adding a new export format is a new module in ranobelib/exporters/ implementing
Exporter and decorated with @register; no changes needed elsewhere.
ranobelib.exporters.Exporter
classExporter() Protocol
Renders a title's chapters to a single file in some format.
SOURCE ↗format
attributeformat: strThe registry key this exporter is selected by, e.g. "txt".
export
methodasyncexport(
title: Title,
chapters: list[Chapter],
output_path: Path,
*,
on_chapter: Callable[[], None] | None = None,
headers: Mapping[str, str] | None = None,
) -> PathWrite chapters (in the given order) to output_path.
async since embedding illustrations (epub, pdf) requires downloading them —
the SDK is async-only throughout (see CLAUDE.md), so this can't drop to a sync
HTTP call. txt/fb2 do no I/O and just don't await anything in their bodies.
| Name | Type | Description | Default |
|---|---|---|---|
title | Title | The chapters' parent title, for metadata (name, authors, ...). | |
chapters | list[Chapter] | The chapters to include, in the order they should appear. | |
output_path | Path | Where to write the exported file. | |
on_chapter | Callable[[], None] | None | Called once per chapter processed, if given — drives
| None |
headers | Mapping[str, str] | None | Extra HTTP headers for any downloads the exporter makes (epub/pdf
illustrations), merged over the SDK's browser-like defaults —
| None |
| Type | Description |
|---|---|
Path |
|
ranobelib.exporters.register
functionregister(exporter: ExporterT) -> ExporterTClass decorator: register exporter under its format key.
Registered exporters, keyed by Exporter.format.