API-dokumentation för databasgränssnittet

Det här API:et är trådsäkert (det använder ett låsschema som tillåter flera samtidiga läsare men endast en skrivare). Du kan komma åt API:et så här:

from calibre.library import db
db = db('Path to calibre library folder').new_api

Om du arbetar i en calibre-insticksmodul som är en del av calibres huvudsakliga grafiska gränssnitt får du tillgång till API:et så här i stället:

db = self.gui.current_db.new_api

class calibre.db.cache.Cache(backend, library_database_instance=None)

En cache i minnet för metadata.db-filen från ett calibre-bibliotek. Den här klassen fungerar också som ett trådsäkert API för åtkomst till databasen. Cachen i minnet behålls i normal form för högsta prestanda.

SQLITE används endast för att läsa från och skriva till metadata.db på ett robust sätt. All logik för läsning, sortering, sökning och cachning av tabeller har implementerats på nytt. Detta var nödvändigt för maximal prestanda och flexibilitet.

class EventType(*values)

book_created = 4

När en ny bokpost skapas i databasen, med bokens ID som enda argument

book_edited = 8

När ett bokformat redigeras, med argument: (book_id, fmt)

books_removed = 5

När böcker tas bort från databasen med listan över bok-ID som enda argument

format_added = 2

När ett format läggs till i en bok, med argumenten: (book_id, format)

formats_removed = 3

När format tas bort från en bok, med argumentet: (mappning från bok-ID till mängden format som tagits bort från boken)

indexing_progress_changed = 9

När indexeringsförloppet ändras

items_removed = 7

När objekt som taggar eller författare tas bort från vissa böcker. Argument: (field_name, berörda bok-id, id för borttagna poster)

items_renamed = 6

När objekt som taggar eller författare byter namn i vissa eller alla böcker. Argument: (field_name, berörda bok-ID:n, mappning från gammalt objekt-ID till nytt objekt-ID)

links_changed = 11

När länkarna som hör till objekt ändras, med argumenten: (field_name, item_ids)

metadata_changed = 1

När metadata ändras för vissa böcker, med argumenten: (namnet på det ändrade fältet, mängden berörda bok-ID:n)

notes_changed = 10

När anteckningarna som hör till objekt ändras, med argumenten: (field_name, item_ids)

add_books(books, add_duplicates=True, apply_import_tags=True, preserve_uuid=False, run_hooks=True, dbapi=None)

Lägg till de angivna böckerna i biblioteket. Böckerna ska anges som en itererbar samling av 2-tupler. Varje tupel ska ha formen (mi, format_map), där mi är ett Metadata-objekt och format_map är en uppslagstabell av formen {fmt: path_or_stream}, exempelvis {'EPUB': '/path/to/file.epub'}.

Returnerar ett par listor: ids, duplicates. ids innehåller bok-ID:n för alla nyskapade böcker i databasen. duplicates innehåller (mi, format_map) för alla böcker som redan finns i databasen enligt den enkla heuristiken för dubblettidentifiering som används av has_book().

add_custom_book_data(name, val_map, delete_first=False)

Lägg till data för name, där val_map är en mappning från book_ids till värden. Om delete_first är True tas alla tidigare lagrade data för name bort.

add_extra_files(book_id, map_of_relpath_to_stream_or_path, replace=True, auto_rename=False)

Lägg till extra datafiler

add_format(book_id, fmt, stream_or_path, replace=True, run_hooks=True, dbapi=None)

Lägg till ett format i den angivna boken. Returnera True om formatet har lagts till.

Parametrar:

• replace – Om värdet är True ersätts det befintliga formatet. Annars returneras False om formatet redan finns.

• run_hooks – Om värdet är True körs filtypsinsticksmoduler på formatet före och efter att det läggs till.

• dbapi – Endast internt bruk.

add_listener(event_callback_function, check_already_added=False)

Registrera en återanropningsfunktion som anropas efter att vissa åtgärder har utförts i denna databas. Funktionen måste ta emot tre argument: (EventType, library_id, event_type_specific_data)

add_notes_resource(path_or_stream_or_data, name: str, mtime: float | None = None) → int

Lägg till den angivna resursen så att den kan refereras av anteckningar och returnera dess innehållshash

all_annotation_styles()

Returnera en tupel med alla inbyggda noteringsstilar.

all_annotation_types()

Returnera en tupel med alla noteringstyper i databasen.

all_annotation_users()

Returnera en tupel med alla (user_type, användarnamn) som har noteringar.

all_annotations(restrict_to_user=None, limit=None, annotation_type=None, annotation_style=None, ignore_removed=False, restrict_to_book_ids=None)

Returnera en tupel med alla noteringar som matchar de angivna kriterierna. ignore_removed styr om borttagna (raderade) noteringar också returneras. Borttagna noteringar består bara av en grundstruktur som används för att slå samman noteringar.

all_annotations_for_book(book_id)

Returnera en tupel med alla noteringar för angivet book_id. Varje notering är en uppslagstabell med nycklarna: format, user_type, user, annotation. Här innehåller annotation noteringsdata.

all_book_ids(type=<class 'frozenset'>)

Oföränderlig mängd med alla kända bok-ID:n.

all_field_for(field, book_ids, default_value=None)

Samma som field_for, förutom att det fungerar på flera böcker samtidigt

all_field_ids(name)

Oföränderlig mängd med ID:n för alla värden i fältet name.

all_field_names(field)

Oföränderlig mängd med alla fältnamn (bör endast användas för fält med många-till-en- eller många-till-många-relationer)

annotation_count_for_book(book_id)

Returnera antalet noteringar för den angivna boken som finns i databasen.

annotations_map_for_book(book_id, fmt, user_type='local', user='viewer')

Returnera en mappning från noteringstyp till noteringsdata för angivna book_id, format, user och user_type.

author_data(author_ids=None) → dict[int, dict[str, str]]

Returnera författardata som en uppslagstabell med nycklarna: name, sort, link

Om inga författare med angivna identiteter hittas returneras en tom uppslagstabell. Om author_ids är None, returneras data för alla författare.

author_sort_from_authors(authors, key_func=<function make_change_case_func.<locals>.change_case>)

Utifrån en lista med författare, returnera author_sort-strängen för författarna. Använd i första hand det författarsorteringsvärde som är kopplat till författaren och i andra hand den beräknade strängen.

author_sorts(author_ids=None) → dict[int, str]

Returnera författarsorteringsvärden för angivna författare.

Om inga författare med angivna identiteter hittas returneras en tom uppslagstabell. Om author_ids är None, returneras data för alla författare.

books_for_field(name, item_id)

Returnera alla böcker som är kopplade till objektet som identifieras av item_id, där objektet tillhör fältet name.

Det returnerade värdet är en mängd med bok-ID:n, eller den tomma mängden om objektet eller fältet inte finns.

books_in_virtual_library(vl, search_restriction=None, virtual_fields=None)

Returnera mängden böcker i det angivna virtuella biblioteket

compress_covers(book_ids, jpeg_quality=100, progress_callback=None)

Komprimera omslagsbilderna för de angivna böckerna. En komprimeringskvalitet på 100 ger förlustfri komprimering, annars används förstörande komprimering.

Återanropningsfunktionen för förloppet anropas med book_id samt den gamla och den nya storleken för varje bok som har bearbetats. Om ett fel inträffar är den nya storleken en sträng med feldetaljer.

copy_cover_to(book_id, dest, use_hardlink=False, report_file_size=None)

Kopiera omslaget till det fillika objektet dest. Returnerar False om inget omslag finns eller om dest är samma fil som det aktuella omslaget. dest kan också vara en sökväg. Då kopieras omslaget till den om och endast om sökvägen skiljer sig från den aktuella sökvägen (med hänsyn till skiftlägeskänslighet).

copy_format_to(book_id, fmt, dest, use_hardlink=False, report_file_size=None)

Kopiera formatet fmt till det fillika objektet dest. Om det angivna formatet inte finns, ges NoSuchFormat-fel. dest kan också vara en sökväg (till en fil), i vilket fall formatet kopieras till den, om och endast om sökvägen skiljer sig från den aktuella sökvägen (med hänsyn till skiftlägeskänslighet).

cover(book_id, as_file=False, as_image=False, as_path=False, as_pixmap=False)

Returnera omslagsbilden eller None. Som standard returneras omslaget som en bytesträng.

VARNING: Om as_path används kopieras omslaget till en temporär fil och sökvägen till den temporära filen returneras. Du bör ta bort filen när du är klar med den.

Parametrar:

• as_file – Om värdet är True returneras bilden som ett öppet filobjekt (en SpooledTemporaryFile)

• as_image – Om värdet är True returneras bilden som ett QImage-objekt

• as_pixmap – Om värdet är True returneras bilden som ett QPixmap-objekt

• as_path – Om värdet är True returneras bilden som en sökväg till en temporär fil

data_for_find_identical_books()

Returnera data som kan användas för att implementera find_identical_books() i en arbetsprocess utan tillgång till db. Se db.utils för en implementering.

data_for_has_book()

Returnera data som är lämpliga för användning i has_book(). Detta kan användas för en implementering av has_book() i en arbetsprocess utan tillgång till databasen.

delete_annotations(annot_ids)

Ta bort noteringar med de angivna identiteterna.

delete_custom_book_data(name, book_ids=())

Ta bort data för name. Som standard tas alla data bort. Om du bara vill ta bort data för vissa bok-ID:n skickar du in en lista med dessa bok-ID:n.

delete_trash_entry(book_id, category)

Ta bort en post från papperskorgen. Här är category ’b’ för böcker och ’f’ för format.

embed_metadata(book_ids, only_fmts=None, report_error=None, report_progress=None)

Uppdatera metadata i alla format för angivna book_ids till aktuella metadata i databasen.

expire_old_trash()

Ta bort för gamla poster ur papperskorgen

export_note(field, item_id) → str

Exportera anteckningen som ett enda HTML-dokument med inbäddade bilder som data: URL:er

fast_field_for(field_obj, book_id, default_value=None)

Samma som field_for, förutom att den undviker den extra uppslagningen för att få fältobjektet

field_for(name, book_id, default_value=None)

Returnera värdet för fältet name för boken som identifieras av book_id. Om boken inte finns, saknar ett definierat värde för fältet name eller om fältet inte finns returneras default_value.

default_value används inte för title, title_sort, authors, author_sort och series_index. Det här beror på att dessa alltid har värden i db. default_value används för alla anpassade kolumner.

De returnerade värdena för is_multiple-fält är alltid tupler, även när inga värden hittas. Med andra ord ignoreras default_value. Undantaget är identifiers, där det returnerade värdet alltid är en uppslagstabell. De returnerade tuplerna är alltid i länkordning, det vill säga i den ordning som de skapades.

field_ids_for(name, book_id)

Returnera ID:na (som en tupel) för de värden som fältet name har för boken som identifieras av book_id. Om det inte finns några värden, någon sådan bok eller något sådant fält returneras en tom tupel.

field_supports_notes(field=None) → bool | frozenset

Returnera True om och endast om det angivna fältet stöder anteckningar. Om field är None returneras en frozenset med alla fält som stöder anteckningar.

find_identical_books(mi, search_restriction='', book_ids=None)

Hittar böcker som har en övermängd av författarna i mi och samma titel (titeln matchas ungefärligt). Se även data_for_find_identical_books().

format(book_id, fmt, as_file=False, as_path=False, preserve_filename=False)

Returnera e-bokformat som en bytesträng eller None om formatet inte finns, eller om vi inte har behörighet att skriva till e-bokfilen.

Parametrar:

• as_file – Om värdet är True returneras e-bokformatet som ett filobjekt. Observera att filobjektet är en SpooledTemporaryFile. Om du vill kopiera formatet till en annan fil bör du därför använda copy_format_to() i stället, för bättre prestanda.

• as_path – Kopierar formatfilen till en temporär fil och returnerar sökvägen till den temporära filen

• preserve_filename – Om värdet är True och en sökväg returneras är filnamnet detsamma som det som används i biblioteket. Observera att detta innebär att upprepade anrop ger samma temporära fil (som återskapas varje gång)

format_abspath(book_id, fmt)

Returnera den absoluta sökvägen till e-bokfilen i formatet format. Du bör nästan aldrig använda detta, eftersom det bryter trådsäkerhetsgarantin i detta API. Använd i stället copy_format_to().

Används för närvarande endast i calibredb list, visaren, Redigera bok, compare_format med originalformatet, Öppna med, massredigering av metadata och katalogerna (via get_data_as_dict()).

Bortsett från visaren, Öppna med och Redigera bok tror jag inte att någon av de andra skriver till filer med hjälp av resultaten från detta anrop.

format_hash(book_id, fmt)

Returnera hashvärdet för det angivna formatet för den angivna boken. Vilken typ av hash som används beror på bakänden, men det är oftast SHA-256.

format_metadata(book_id, fmt, allow_cache=True, update_db=False)

Returnera path, size och mtime för det angivna formatet för den angivna boken. Du bör bara använda sökvägen om det är absolut nödvändigt, eftersom direkt åtkomst till den bryter trådsäkerhetsgarantierna i detta API. Använd i stället metoden copy_format_to().

Parametrar:

• allow_cache – Om värdet är True används cachade värden, annars görs en långsam åtkomst till filsystemet. Cachevärdena kan vara inaktuella om filsystemet har använts utanför detta API.

• update_db – Om värdet är True uppdateras databasens max_size-fält för denna bok.

formats(book_id, verify_formats=True)

Returnera en tupel med alla format för den angivna boken. Om verify_formats är True kontrolleras att filerna finns på disken.

get_all_items_that_have_notes(field_name=None) → set[int] | dict[str, set[int]]

Returnera alla item_ids för objekt som har anteckningar i det angivna fältet, eller i alla fält om field_name är None

get_all_link_maps_for_book(book_id)

Returnerar alla länkar för alla fält som boken med angivet book_id hänvisar till. Om book_id inte finns returnerar metoden {}.

Exempel: Anta att författare A har länk X, författare B har länk Y, tagg S har länk F och tagg T har länk G. Om bok 1 har författare A och tagg T returnerar denna metod {’authors’:{’A’:’X’}, ’tags’:{’T’, ’G’}}. Om bok 2 saknar taggar och dess författare varken är A eller B returnerar denna metod {}.

Parametrar:

book_id – bok-ID:t i fråga.

Returer:

{field: {field_value, link_value}, … för alla fält med ett field_value som har ett icke-tomt länkvärde för den boken

get_book_path(book_id, sep='/', unsafe=False)

Returnera den relativa sökvägen till boken för angivet ID. Använd helst denna metod, eftersom du kan välja katalogseparator. Som standard används operativsystemets separator. Om unsafe är True tillåts None som returvärde om book_id inte finns i biblioteket.

get_categories(sort='name', book_ids=None, already_fixed=None, first_letter_sort=False, uncollapsed_categories=None)

Används internt för att implementera taggbläddraren

get_custom_book_data(name, book_ids=(), default=None)

Hämta data för name. Som standard returneras data för alla book_ids. Skicka in en lista med bok-ID:n om du bara vill ha data för vissa böcker. Returnerar en mappning från book_id till värden. Om ett visst värde inte kan avkodas används default för det.

get_id_map(field)

Returnera en mappning från ID-nummer till värden för det angivna fältet. Fältet måste ha en många-till-en- eller många-till-många-relation, annars utlöses ett ValueError.

get_ids_for_custom_book_data(name)

Returnera mängden bok-ID:n som name har data för.

get_item_id(field, item_name, case_sensitive=False)

Returnera post-ID:t för item_name eller None om det inte hittas. Funktionen är mycket långsam vid uppslagning av flera namn; använd i stället get_item_ids() eller get_item_name_map(). Skiftlägeskänsliga uppslagningar är också snabbare än skiftlägesokänsliga.

get_item_ids(field, item_names, case_sensitive=False)

Returnera en uppslagstabell som mappar item_name till objektets ID eller None

get_item_name(field, item_id)

Returnera postnamnet för posten som anges av item_id i specificerat fält. Se också get_id_map().

get_item_name_map(field, normalize_func=None)

Returnera en mappning från objektvärden till ID:n

get_link_map(for_field)

Returnera en uppslagstabell med länkar för det angivna fältet.

Parametrar:

for_field – uppslagsnamnet för fältet som länkmappningen önskas för

Returer:

{field_value:link_value, …} för icke-tomma länkar

get_metadata(book_id, get_cover=False, get_user_categories=True, cover_as_data=False)

Returnera metadata för boken som identifieras av book_id som ett calibre.ebooks.metadata.book.base.Metadata-objekt. Observera att formatlistan inte kontrolleras. Om get_cover är True returneras omslaget, antingen som en sökväg till en temporär fil i mi.cover eller, om cover_as_data är True, som mi.cover_data.

get_next_series_num_for(series, field='series', current_indices=False)

Returnera nästa serieindex för den angivna serien, med hänsyn till de olika inställningar som styr genereringen av nästa nummer i serien.

Parametrar:

• field – Det serieliknande fältet (standard är den inbyggda seriekolumnen)

• current_indices – Om värdet är True returneras i stället en mappning från book_id till det aktuella värdet för series_index.

get_notes_resource(resource_hash) → dict | None

Returnera en uppslagstabell som innehåller resursdata och namn, eller None om ingen resurs med angiven hash hittas

get_pages(book_id: int) → Pages | None

Returnera information om sidantal för den angivna boken

get_proxy_metadata(book_id)

Som get_metadata(), men returnerar ett ProxyMetadata-objekt som bara läser värden från databasen vid behov. Detta är mycket snabbare än get_metadata när endast ett fåtal fält i det returnerade metadataobjektet behöver användas.

get_usage_count_by_id(field)

Returnera en mappning från ID till antal användningar för alla värden i det angivna fältet, som måste ha en många-till-en- eller många-till-många-relation.

has_book(mi)

Returnera True om och endast om databasen innehåller en post med samma titel som det angivna Metadata-objektet. Jämförelsen är skiftlägesokänslig. Se även data_for_has_book().

has_format(book_id, fmt)

Returnera True om och endast om formatet finns på disken

has_id(book_id)

Returnera True om och endast om angivet book_id finns i databasen

import_note(field, item_id, path_to_html_file, path_is_data=False)

Importera en tidigare exporterad anteckning eller en godtycklig HTML-fil som anteckning för den angivna posten

init()

Initiera denna cache med data från bakänden.

items_with_notes_in_book(book_id: int) → dict[str, dict[int, str]]

Returnera en uppslagstabell som mappar fält till objekt med tillhörande anteckningar i respektive fält för den angivna boken

link_for(field, item_id)

Returnera länken, om någon, för det angivna objektet eller None om ingen länk hittas

list_extra_files(book_id, use_cache=False, pattern='') → tuple[ExtraFile, ...]

Få information om extra filer i bokens mapp.

Parametrar:

• book_id – bokens ID i databasen

• pattern – det filnamnsmönster som ska sökas efter. Ett tomt mönster matchar alla extra filer. Mönster måste använda / som separator. Använd konstanten DATA_FILE_PATTERN för att matcha filer i datamappen.

Returer:

En tupel med alla extra filer som matchar det angivna mönstret. Varje element i tupeln är ExtraFile(relpath, file_path, stat_result). Här är relpath filens sökväg relativt bokkatalogen, med / som separator. stat_result är resultatet av att anropa os.stat() på filen.

mark_for_pages_recount(book_id: int = 0) → None

Markera alla böcker för omräkning av sidor

merge_annotations_for_book(book_id, fmt, annots_list, user_type='local', user='viewer')

Slå samman de angivna noteringarna med de befintliga noteringarna för book_id, fm, user_type och user.

merge_extra_files(dest_id, src_ids, replace=False)

Slå samman de extra filerna från src_ids till dest_id. Filer med namnkonflikter får automatiskt nya namn, såvida inte replace=True, då de ersätts.

move_book_from_trash(book_id)

Ångra borttagning av en bok från papperskorgen

move_format_from_trash(book_id, fmt)

Ångra borttagning av ett format från papperskorgen

multisort(fields, ids_to_sort=None, virtual_fields=None)

Returnera en lista med sorterade bok-ID:n. Om ids_to_sort är None returneras alla bok-ID:n.

fields måste vara en lista med 2-tupler av formen (field_name, ascending=True eller False). Den första 2-tupeln anger det fält som har högst prioritet vid sorteringen.

notes_data_for(field, item_id) → dict[str, Any] | None

Returnera alla anteckningsdata som en uppslagstabell, eller None om anteckningen inte finns

notes_for(field, item_id) → str

Returnera anteckningsdokumentet eller en tom sträng om det inte hittas

notes_resources_used_by(field, item_id)

Returnera mängden resurshashar för alla resurser som används av anteckningen för det angivna objektet

pages_needs_scan(books: Iterable[int] = ()) → set[int]

Returnera de böcker i delmängden (eller bland alla böcker om delmängden är tom) som är markerade som att de behöver skannas för att uppdatera sidantalet

pref(name, default=None, namespace=None, get_default_from_defaults=False)

Returnera värdet för den angivna inställningen eller värdet som anges som default om inställningen inte har angetts.

queue_pages_scan(book_id: int = 0, force: bool = False, by_user: bool = True) → None

Starta en skanning som uppdaterar sidantalet för alla böcker som behöver skannas. Om book_id anges skannas endast den boken, och den skannas alltid. När force är True tas det befintliga värdet för sidantal bort, om det finns, så att boken tvingas skannas om även om värdet var aktuellt.

read_backup(book_id)

Returnera OPF-metadata-säkerhetskopian för boken som en bytesträng eller None om ingen sådan säkerhetskopia finns.

refresh_format_sizes(size_map: dict[tuple[int, str], int]) → set[int]

Uppdatera databasen med storlekarna på disken för de angivna formatfilerna. size_map mappar (book_id, fmt) till formatfilens storlek. Används för att rätta lagrade storlekar som har blivit inaktuella eftersom formatfiler har ändrats utanför calibre. Returnerar ID:na för de böcker vars lagrade storlekar ändrades.

remove_books(book_ids, permanent=False)

Ta bort böckerna som specificeras av book_ids från databasen och ta bort deras formatfiler. Om permanent är False, placeras formatfilerna i papperskorgen per bibliotek.

remove_extra_files(book_id: int, relpaths: Iterable[str], permanent=False) → dict[str, Exception | None]

Ta bort de angivna extrafilerna, antingen till papperskorgen eller permanent.

remove_formats(formats_map, db_only=False)

Ta bort de angivna formaten från de angivna böckerna.

Parametrar:

• formats_map – En mappning från book_id till en lista med format som ska tas bort från boken.

• db_only – Om värdet är True tas endast formatets post bort från databasen. Själva formatfilen tas inte bort från filsystemet.

Returer:

En mappning från bok-ID till mängden format som faktiskt har tagits bort från filsystemet för den boken

remove_items(field, item_ids, restrict_to_book_ids=None)

Ta bort alla objekt med angivna ID:n i det angivna fältet. Returnerar mängden berörda bok-ID:n. restrict_to_book_ids är en valfri mängd med bok-ID:n. Om den anges tas objekten endast bort från dessa böcker.

rename_extra_files(book_id, map_of_relpath_to_new_relpath, replace=False)

Byt namn på extra datafiler

rename_items(field, item_id_to_new_name_map, change_index=True, restrict_to_book_ids=None)

Byt namn på objekt i ett fält med en många-till-en- eller många-till-många-relation, till exempel taggar eller serier.

Parametrar:

• change_index – Vid byte av namn i ett serieliknande fält ändras också värdena för series_index.

• restrict_to_book_ids – En valfri mängd med bok-ID:n för vilka namnbytet ska utföras. Som standard omfattas alla böcker.

restore_book(book_id, mi, last_modified, path, formats, annotations=())

Återställ bokposten i databasen för en bok som redan finns i filsystemet

restore_original_format(book_id, original_fmt)

Återställ det angivna formatet från tidigare sparat ORIGINAL_FORMAT, om det finns. Returnera True om återställningen lyckas. ORIGINAL_FORMAT tas bort efter en lyckad återställning.

property safe_read_lock

Ett säkert läslås är ett lås som inte gör något om tråden redan har ett skrivlås. Annars skaffar det ett läslås. Detta är nödvändigt för att förhindra DowngradeLockErrors, som kan uppstå när sökcachen uppdateras och det finns sammansatta kolumner. Vid uppdatering av sökcachen hålls ett exklusivt lås, men sökning i en sammansatt kolumn innebär att fältvärden läses via ProxyMetadata, som försöker skaffa ett delat lås. Detta kan även utlösas i andra situationer.

Den här egenskapen returnerar ett nytt låsobjekt vid varje åtkomst. Av prestandaskäl är låsobjektet inte rekursivt och får endast användas i en with-sats som with cache.safe_read_lock:. Annars uppstår problem.

save_original_format(book_id, fmt)

Spara en kopia av det angivna formatet som ORIGINAL_FORMAT och skriv över eventuellt befintligt ORIGINAL_FORMAT.

search(query, restriction='', virtual_fields=None, book_ids=None, allow_templates=True)

Sök i databasen med den angivna sökfrågan och returnera en mängd med matchande bok-ID:n.

Parametrar:

• restriction – En begränsning som kombineras med den angivna sökfrågan med AND. Observera att begränsningar cachas, så sökningen a AND b är långsammare än a med begränsningen b.

• virtual_fields – Används internt (virtuella fält, till exempel on_device, att söka i).

• book_ids – Om värdet inte är None är det en mängd med bok-ID:n som begränsar sökningen till dessa böcker i stället för alla böcker.

search_annotations(fts_engine_query, use_stemming=True, highlight_start=None, highlight_end=None, snippet_size=None, annotation_type=None, restrict_to_book_ids=None, restrict_to_user=None, ignore_removed=False, annotation_style=None)

Returnera en tupel med noteringar som matchar den angivna fulltextsökfrågan.

search_notes(fts_engine_query='', use_stemming=True, highlight_start=None, highlight_end=None, snippet_size=None, restrict_to_fields=(), return_text=True, result_type=<class 'tuple'>, process_each_result=None, limit=None)

Sök i anteckningstexten med hjälp av ett FTS-index. Om sökfrågan är tom returneras alla anteckningar.

set_annotations_for_book(book_id, fmt, annots_list, user_type='local', user='viewer')

Ange alla noteringar för angivna book_id, fmt, user_type och user.

set_conversion_options(options, fmt='PIPE')

options måste vara en mappning av formen {book_id:conversion_options}

set_cover(book_id_data_map)

Ange omslaget för denna bok. Data kan vara ett QImage-objekt, ett QPixmap-objekt, ett filobjekt eller en bytesträng. Det kan också vara None, vilket innebär att eventuellt befintligt omslag tas bort.

set_field(name, book_id_to_val_map, allow_case_change=True, do_path_update=True)

Ange värdena för fältet som anges av name. Returnerar mängden av alla bok-ID:n som påverkades av ändringen.

Parametrar:

• book_id_to_val_map – Mappning från book_ids till värden som ska tillämpas.

• allow_case_change – Om värdet är True ändras skiftläget i fält med en många-till-en- eller många-till-många-relation. Om en bok till exempel har taggen tag1 och du anger taggen Tag1 för en annan bok får båda böckerna taggen Tag1 om allow_case_change är True. Annars får båda taggen tag1.

• do_path_update – Används internt, du bör aldrig ändra det.

set_link_map(field, value_to_link_map, only_set_if_no_existing_link=False)

Anger länkar för objektvärden i field. Obs: Den här metoden ändrar inte värden som saknas i value_to_link_map

Parametrar:

• field – uppslagsnamnet

• value_to_link_map – dict(field_value:link, …). Observera att detta är värden, inte fältidentiteter.

Returer:

böcker som ändrats genom att länken angetts

set_metadata(book_id, mi, ignore_errors=False, force_changes=False, set_title=True, set_authors=True, allow_case_change=False)

Ange metadata för boken id från Metadata-objektet mi

Inställningen force_changes=True tvingar set_metadata att uppdatera fält även om mi innehåller tomma värden. I detta fall skiljs None från tomma värden. Om mi.XXX är None ersätts inte XXX, annars görs det. Attributen tags, identifiers och cover är specialfall. tags och identifiers kan inte anges till None, så de ersätts alltid om force_changes är True. Du måste se till att mi innehåller de värden du vill att boken ska ha. Omslag ändras alltid om ett nytt omslag tillhandahålls, men tas aldrig bort. Observera också att force_changes inte påverkar inställningen av title eller authors.

set_notes_for(field, item_id, doc: str, searchable_text: str = '', resource_hashes=(), remove_unused_resources=False) → int

Ange anteckningsdokumentet. Om den sökbara texten skiljer sig från dokumentet anger du den som searchable_text. Om dokumentet hänvisar till resurser måste deras hashar finnas i resource_hashes. Ange remove_unused_resources till True för att rensa oanvända resurser. Observera att uppdatering av en anteckning ändå automatiskt rensar resurser som hör till den anteckningen.

set_pages(book_id: int, pages: int = 0, algorithm: int = 0, format: str = '', format_size: int = 0) → None

Ange information om sidantal för den angivna boken

set_pref(name, val, namespace=None)

Ange det angivna värdet för den angivna inställningen. Se även pref().

split_if_is_multiple_composite(f, val)

Om f är uppslagsnyckeln för en sammansatt kolumn och kolumnen är is_multiple delas v upp i unika, icke-tomma värden. Jämförelsen är skiftlägeskänslig. Ordningen bevaras inte. Returnera en list() för kompatibilitet med metoderna som hämtar fältvärden i proxymetadata, till exempel tags.

tags_older_than(tag, delta=None, must_have_tag=None, must_have_authors=None)

Returnera ID:n för alla böcker med taggen tag som är äldre än den angivna tiden. Taggjämförelsen är skiftlägesokänslig.

Parametrar:

• delta – Ett timedelta-objekt eller None. Om värdet är None returneras alla ID:n med taggen.

• must_have_tag – Om värdet inte är None begränsas listan till böcker som har den här taggen

• must_have_authors – En lista över författare. Om värdet inte är None begränsas matchningslistan till böcker som har dessa författare (skiftlägesokänsligt).

unretire_note_for(field, item_id) → int

Återaktivera en tidigare inaktiverad anteckning för det angivna objektet. Anteckningar inaktiveras när ett objekt tas bort från databasen

update_annotations(annot_id_map)

Uppdatera noteringar.

user_categories_for_books(book_ids, proxy_metadata_map=None)

Returnera användarkategorierna för de angivna böckerna. proxy_metadata_map är valfritt och kan förbättra prestandan i sammanhang där ett ProxyMetadata-objekt för böckerna redan finns. Det bör vara en mappning från book_ids till motsvarande ProxyMetadata-objekt.

© Copyright Kovid Goyal. Senast uppdaterad den sep. 18, 2026.