ranobelib API reference
Текст страницы — оригинал из репозитория SDK, на английском. Исходный файл ↗
Entry point
ranobelib.RanobeLib
классRanobeLib(
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.
ИСХОДНИК ↗slug_url
атрибутсвойствоslug_url: strThe title's {id}--{slug} identifier.
aclose
методasyncaclose() -> NoneClose the underlying HTTP client.
ИСХОДНИК ↗download_title
методasyncdownload_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
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
методasyncestimate_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
int | The estimated size in bytes, or |
int | its chapters have a translation |
| Тип | Описание |
|---|---|
ValueError | If both |
export
методasyncexport(chapters: list[Chapter], *, fmt: str, path: str | Path) -> PathExport chapters to a file.
| Имя | Тип | Описание |
|---|---|---|
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 |
| Тип | Описание |
|---|---|
ValueError | If |
get_chapter
методasyncget_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
MultipleTranslationsError | If the chapter has more than one translation and
|
get_chapters
методasyncget_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.
| Имя | Тип | Описание |
|---|---|---|
chapters | list[tuple[int, str]] | A list of |
| Тип | Описание |
|---|---|
ChapterNotFoundError | If any requested chapter doesn't exist. |
MultipleTranslationsError | If any requested chapter has more than one translation. |
get_info
методasyncget_info(*, refresh: bool = False) -> TitleTFetch title metadata: names, cover, summary, genres, tags, authors, teams.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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
методasyncget_table_of_contents(*, refresh: bool = False) -> list[VolumeT]Fetch the title's volumes and chapter names/numbers, without chapter content.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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
методasyncget_translations(volume: int, number: str) -> list[ChapterBranch]Fetch the available translations (branches) for a chapter.
| Имя | Тип | Описание |
|---|---|---|
volume | int | The chapter's volume number. |
number | str | The chapter number. |
| Тип | Описание |
|---|---|
ChapterNotFoundError | If no chapter exists for this volume/number. |
get_volume
методasyncget_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.
| Имя | Тип | Описание |
|---|---|---|
volume | int | The volume number. |
| Тип | Описание |
|---|---|
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
методasyncget_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.
| Имя | Тип | Описание |
|---|---|---|
volumes | list[int] | The volume numbers to fetch. |
| Тип | Описание |
|---|---|
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
классCatalog(
*,
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
методasyncaclose() -> NoneClose the underlying HTTP client.
ИСХОДНИК ↗list_countries
методasynclist_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the country list was already cached. | False |
| Тип | Описание |
|---|---|
list[Country] | Every |
list_genres
методasynclist_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).
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the genre list was already cached. | False |
| Тип | Описание |
|---|---|
list[Genre] | Every |
list_statuses
методasynclist_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
refresh | bool | Bypass the disk cache and re-fetch from the API even if the status list was already cached. | False |
| Тип | Описание |
|---|---|
list[Label] | Every status ( |
list_titles
методasynclist_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
CatalogPage[TitleT] | A |
| Тип | Описание |
|---|---|
ValueError | If |
Models
ranobelib.CatalogPage
классCatalogPage() _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
классTitle() _core.Title
Metadata for a single title (novel).
ИСХОДНИК ↗base_names
атрибутсвойствоbase_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
атрибутchapter_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
атрибутlast_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
классChapter() _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
классFootnote() 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
атрибутcontent: strSanitized inline HTML (same tag vocabulary as Chapter.content), without the arrow
and without a wrapping <p>.
ranobelib.Volume
классVolume()A volume: its number and the chapters it contains, in title order.
ИСХОДНИК ↗ranobelib.ChapterBranch
классChapterBranch() 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
классGenre() BaseModel
A genre tag (e.g. Fantasy, Romance).
ИСХОДНИК ↗ranobelib.Country
классCountry() 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
классLabel() BaseModel
A small {id, label} enum value used throughout the API (status, age rating, ...).
Exceptions
ranobelib.RanobeLibError
атрибутRanobeLibError = LibSocialErrorBase class for all errors raised by the SDK (libsocial.LibSocialError).
ranobelib.TitleNotFoundError
классTitleNotFoundError(slug_url: str)Raised when a title cannot be found on the site.
| Имя | Тип | Описание |
|---|---|---|
slug_url | The title's |
ranobelib.ChapterNotFoundError
классChapterNotFoundError(slug_url: str, *, volume: str, number: str)Raised when a chapter cannot be found for a given volume/number.
| Имя | Тип | Описание |
|---|---|---|
slug_url | The title's | |
volume | The volume number that was requested. | |
number | The chapter number that was requested. |
ranobelib.VolumeNotFoundError
классVolumeNotFoundError(slug_url: str, *, volume: str)Raised when a title has no chapters for a given volume number.
| Имя | Тип | Описание |
|---|---|---|
slug_url | The title's | |
volume | The volume number that was requested. |
ranobelib.MultipleTranslationsError
классMultipleTranslationsError(
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.
| Имя | Тип | Описание |
|---|---|---|
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
классMultipleTitleTranslationsError(
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=...).
| Имя | Тип | Описание |
|---|---|---|
slug_url | The title's | |
chapters | The ambiguous chapters and their available translations. |
ranobelib.AuthRequiredError
классAuthRequiredError(url: str)Raised when the requested content requires authorization (paid or early access).
| Имя | Тип | Описание |
|---|---|---|
url | The request URL that returned 403. |
ranobelib.AccessBlockedError
классAccessBlockedError(
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.
| Имя | Тип | Описание |
|---|---|---|
url | The request URL that returned 403. |
ranobelib.RateLimitError
классRateLimitError(retry_after: float | None = None)Raised when the API responds with 429 Too Many Requests.
| Имя | Тип | Описание |
|---|---|---|
retry_after | The response's |
ranobelib.DownloadTitleInterruptedError
классDownloadTitleInterruptedError(
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.
| Имя | Тип | Описание |
|---|---|---|
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
функцияcache_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
cache_dir | str | Path | The cache directory — the same | DEFAULT_CACHE_DIR |
| Тип | Описание |
|---|---|
CacheStats | The number of entries and their total size in bytes. A missing directory is an empty |
CacheStats | cache, |
ranobelib.clear_cache
функцияclear_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
CacheStats | The number of entries removed and the bytes they took. A missing directory removes |
CacheStats | nothing, |
| Тип | Описание |
|---|---|
ValueError | If |
ranobelib.CacheStats
классCacheStats(entries: int, bytes: int)How many cache entries there are (or were removed), and their total size on disk.
ИСХОДНИК ↗Sizing
ranobelib.chapter_size
функцияchapter_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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via | |
average_image_size | int | Assumed bytes per | DEFAULT_AVERAGE_IMAGE_SIZE |
| Тип | Описание |
|---|---|
ValueError | If |
ranobelib.volume_size
функцияvolume_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().
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
volume | Volume | A volume whose chapters have content already fetched (e.g. via
| |
average_image_size | int | Forwarded to | DEFAULT_AVERAGE_IMAGE_SIZE |
| Тип | Описание |
|---|---|
ValueError | If any chapter in |
Chapter content
ranobelib.chapter_image_urls
функцияchapter_image_urls(chapter: Chapter) -> list[str]List the image URLs a fetched chapter references.
| Имя | Тип | Описание |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
| Тип | Описание |
|---|---|
list[str] | Every |
list[str] | document order, each URL listed once (its first occurrence). |
| Тип | Описание |
|---|---|
ValueError | If |
ranobelib.rewrite_image_urls
функцияrewrite_image_urls(
chapter: Chapter,
replace: Callable[[str], str],
) -> ChapterReturn a copy of a fetched chapter with every <img src> passed through replace.
| Имя | Тип | Описание |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
replace | Callable[[str], str] | Called with each image URL (once per |
| Тип | Описание |
|---|---|
ValueError | If |
ranobelib.chapter_paragraphs
функцияchapter_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.
| Имя | Тип | Описание |
|---|---|---|
chapter | Chapter | A chapter with content already fetched (e.g. via |
| Тип | Описание |
|---|---|
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 |
| Тип | Описание |
|---|---|
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
классExporter() Protocol
Renders a title's chapters to a single file in some format.
ИСХОДНИК ↗format
атрибутformat: strThe registry key this exporter is selected by, e.g. "txt".
export
методasyncexport(
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.
| Имя | Тип | Описание | По умолчанию |
|---|---|---|---|
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 |
| Тип | Описание |
|---|---|
Path |
|
ranobelib.exporters.register
функцияregister(exporter: ExporterT) -> ExporterTClass decorator: register exporter under its format key.
Registered exporters, keyed by Exporter.format.