API-dokumentation för databasgränssnittet

Denna API är trådsäker (använder ett flerläsar-, singelskrivarutelåsningsschema). Du kan komma åt denna API så här:

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

Om du är i en calibre-insticksmodul som är en del av calibres huvudanvändargränssnitt får du tillgång till den så här istä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 helt enkelt som ett sätt att läsa och skriva från metadata.db robust. All logik för läsning/sortering/sökning/cachning av tabeller är återimplementerad. Detta var nödvändigt för maximal prestanda och flexibilitet.

class EventType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

book_created = 4

När en ny bokpost skapas i databasen, med bokidentitet 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 argument: (bok_id, format)

formats_removed = 3

När format tas bort från en bok, med argument: (kartläggning av bok-id till uppsättning format borttagna 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 objekt)

items_renamed = 6

När objekt som taggar eller författare byter namn i vissa eller alla böcker. Argument: (fältnamn, påverkade bok-id:er, kartläggning av gammalt post-id till nytt post-id)

metadata_changed = 1

När vissa metadata ändras för vissa böcker, med argument: (namn på ändrat fält, uppsättning påverkade bok-id)

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öcker bör vara en uppräknelig mängd i multipel av 2, varje multipel av 2 med formen (mi, format_map) där mi är ett metadataobjekt och format_map är en ordbok med formen {fmt: path_or_stream}, till exempel: {'EPUB': '/sökväg/till/fil.epub'}.

returnerar ett listpar: ids, duplicates. id innehållande bokens identiteter för all nyligen skapade böcker i databasen. ”duplikat” innehåller (mi, format_map) for alla böcker som redan finns i databasen genom enkel heuristisk duplikationsdetektering använd av has_book().

add_custom_book_data(name, val_map, delete_first=False)

Lägg till data för namn där val_map är en karta över book_ids till värden. Om delete_first är True kommer alla tidigare lagrade data för namn tas 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 True ersätts befintligt format, annars om formatet redan finns, returneras False.

• run_hooks – Om True, körs filtypsinsticksmoduler på formatet innan och efter de tilläggs.

• dbapi – Endast internt bruk.

add_listener(event_callback_function, check_already_added=False)

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

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

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

all_annotation_types()

Returnera en tuppel av alla noteringstyper i databasen.

all_annotation_users()

Returnera en tuppel av alla (användartyp, användarnamn) som har noteringar.

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

Returnera en tuppel av alla noteringar som matchar de angivna kriterierna. ignore_removed styr om borttagna (borttagna) noteringar också returneras. Borttagna noteringar är bara ett skelett som används för att slå samman noteringar.

all_annotations_for_book(book_id)

Returnera en tuppel som innehåller alla noteringar för det angivna book_id som ett dikt med nycklar: format, user_type, user, noteringar. Här är noteringar noteringsdata.

all_book_ids(type=<class 'frozenset'>)

Fryst uppsättning av alla kända bokidentiteter.

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)

Fryst uppsättning av identiteter för alla värden i fältet namn.

all_field_names(field)

Fryst uppsättning av alla fältnamn (bör endast användas för många-ett och många-många fält)

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 karta med noteringstyp -> noteringsdata för angivet bok-id, format, användare och användartyp.

author_data(author_ids=None)

returnerar författardata som ordbok med nycklar: namn, sort, länk

Om inga författare med angivna identiteter hittas returneras en tom ordbok. 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>)

Given en lista med författare, returnera author_sort sträng för författare, framför författarsortering associerad med författare över bearbetade strängen.

books_for_field(name, item_id)

returnerar alla böcker associerade med posten identifierad av item_id, där posten tillhör fältet name.

Returnerat värde är en mängd av bokidentiteter eller den tomma mängden om posten eller fältet inte finns.

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

Returnera uppsättningen 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 kommer att utföra förlustfri komprimering, annars är det förlustbringande.

Framstegsåterkallningen kommer att anropas med book_id och de gamla och nya storlekarna för varje bok som har bearbetats. Om ett fel inträffar kommer den nya storleken att vara en sträng med feldetaljer.

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

Kopiera omslag till filen som objektet dest. Returnerar False om inget omslag finns eller dest är samma fil som det aktuella omslaget. dest kan också vara en sökväg i vilket fall omslaget kopieras till det om och endast om sökvägen är en annan än den aktuella sökvägen (med små bokstäver i beräkningen).

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 omslagsbild eller inget. Som standard, returneras omslag som en byte sträng.

VARNING: Använda as_path kommer att kopiera omslaget till en temporär fil och returnera sökvägen till temporära filen. Du bör ta bort temporära filen när du är klar med den.

Parametrar:

• as_file – Om True returnerar bilden som ett öppet filobjekt (en SpooledTemporaryFile)

• as_image – Om True returnerar bilden som ett Q-bildobjekt

• as_pixmap – Om True returnera bilden som ett QPixmap-objekt

• as_path – Om True returnerar bilden som en sökväg till en temporärfil

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()

returnerar 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 db.

delete_annotations(annot_ids)

Ta bort noteringar med de angivna identiteterna.

delete_custom_book_data(name, book_ids=())

Ta bort data för namn. Som standard tas alla data bort, om du endast vill ta bort data för vissa bokidentifierare, passera i en lista med bokidentifierare.

delete_trash_entry(book_id, category)

Ta bort en post från papperskorgen. Här är kategorin ’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 av de angivna bok_ids till aktuell metadata i databasen.

expire_old_trash()

Förfalla poster från papperskorgen som är för gamla

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 av fältet name för boken som identifieras av book_id. Om ingen sådan bok finns eller inte har något definierat värde för fältet name eller inget sådant fält finns, så 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.

Det återgivna värdet för is_multiple fält är alltid tupler, även om inga värden finns (med andra ord, default_value ignoreras). Undantaget är identifierare som det återgav värdet alltid är en ordbok. De återgivna tuplerna är alltid i länkordning, det vill säga i vilken ordning de skapades.

field_ids_for(name, book_id)

Returnera id:et (som en tupel) för de värden som fältet namn har på boken som identifieras av book_id. Om det inte finns några värden, ingen sådan bok, eller inget sådant fält, returneras en tom tupel.

field_supports_notes(field=None) → bool

Returnera True om det angivna fältet stöder anteckningar. Om fältet är Inget returnera frozenset av 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 är oklart matchad). 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 True returneras e-bokformatet som ett filobjekt. Observera att filobjektet är en SpooledTemporaryFile, så om vad du vill göra är att kopiera formatet till en annan fil, använd copy_format_to() istället för prestanda.

• as_path – Kopierar formatet filen till en temp fil och returnerar sökvägen till temp filen

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

format_abspath(book_id, fmt)

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

Används för närvarande endast i calibredb-listan, visaren, redigera bok, compare_format till originalformat, öppna med, redigera metadata i grupp och katalogerna (via get_data_as_dict()).

Bortsett från visaren, öppna med och redigera boken, tror jag inte någon av de andra gör någon filskrivnings-I/O med resultaten av detta anrop.

format_hash(book_id, fmt)

Returnera hash för det angivna formatet för den angivna boken. Den typ av hash är algoritmberoende, men är oftast SHA-256.

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

Returnera sökväg, storlek och mtime för det specifika formatet för den specifika boken. Du bör inte använda sökväg annat om du absolut måste, eftersom direkt tillgång av den förstör trådsäkerhetsgarantin av denna API. Istället använd copy_format_to() metoden.

Parametrar:

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

• update_db – Om True kommer max_size-fältet i databasen uppdateras för denna bok.

formats(book_id, verify_formats=True)

Returnera tupel av alla format för den specifika boken. Om verify_formats är True verifieras att filer finns på disken.

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

Returnera alla item_ids för poster som har anteckningar i det angivna fältet eller alla fält om fältnamn är None

get_all_link_maps_for_book(book_id)

Returnerar alla länkar för alla fält som hänvisas till av bok som identifieras av book_id. Om book_id inte finns returnerar metoden {}.

Exempel: Antag 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:s författare varken är A eller B och inte har några taggar, returnerar denna metod {}.

Parametrar:

book_id – bokidentitet i fråga.

Returnerar:

{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_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 namn. Som standard returneras data för alla book_ids, förse med en lista med bokidentifierare om du bara vill ha några data. returnerar en översikt av book_id till värden. Om en speciellt värde inte kan identifieras, används istället standardvärde för den.

get_id_map(field)

Returnera en kartläggning av id-nummer till värden för det angivna fältet. Fältet måste vara ett många-en- eller många-många-fält, annars uppstår ett ValueError.

get_ids_for_custom_book_data(name)

Returnera en uppsättning bok-id för vilket namn har data.

get_item_id(field, item_name, case_sensitive=False)

Returnera post-id för item_name eller None om den inte hittas. Den här funktionen är väldigt långsam om man gör uppslagningar för flera namn med antingen get_item_ids() eller get_item_name_map(). På samma sätt är skiftlägeskänsliga sökningar snabbare än skiftlägesokänsliga.

get_item_ids(field, item_names, case_sensitive=False)

Returnera en dict-kartläggning av item_name till post-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 kartläggning av postvärden till identifieringar

get_link_map(for_field)

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

Parametrar:

for_field – uppslagsnamnet för fältet för vilket länkkartan önskas

Returnerar:

{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 identifierat av book_id som ett calibre.ebooks.metadata.book.base.Metadata objekt. Observera att listan av format inte är verifierad. Om get_cover är True, kommer omslag att returneras, antingen som en sökväg till temporärfilen mi.cover eller om cover_as_data är Sant som mi.cover_data.

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

Returnera nästa serieindex för den specifika serien, med beaktning av olika inställningar som styr skapande av nästa serienummer.

Parametrar:

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

• current_indices – Om True, returneras en kartläggning av book_id till aktuellt serie_index-värde istället.

get_notes_resource(resource_hash) → dict | None

Returnera ett dikt som innehåller resursdata och namn eller None om ingen resurs med angiven hash hittas

get_proxy_metadata(book_id)

Liksom: meth:get_metadata förutom att den returnerar ett ProxyMetadata-objekt som bara läser värden från databasen på förfrågan. Det är mycket snabbare än get_metadata när endast ett mindre antal fält behöver nås från returnerat metadataobjekt.

get_usage_count_by_id(field)

Returnera en kartläggning av id till användningsantal för alla värden i det angivna fältet, som måste vara ett många-en- eller många-många-fält.

has_book(mi)

Returnera True om och endast om databasen innehåller en post med samma titel som den angivna i metadataobjektet. Jämförelsen är skiftlägeskä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 specificerad bok_id finns i db

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 backend.

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

Returnera ett dict av fält till poster som har associerade anteckningar för det fältet 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 – databasens bokidentitet för boken

• pattern – mönstret av filnamn att söka efter. 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.

Returnerar:

En tupel av alla extra filer som matchar det angivna mönstret. Varje element i tuplen är ExtraFile(relpath, file_path, stat_result). Där relpath är den relativa sökvägen för filen till bokkatalogen med / som avgränsare. stat_result är resultatet av att anropa os.stat() på filen.

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

Slå samman de angivna noteringarna till 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. Motstridiga filer döps automatiskt om inte replace=True i vilket fall 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 bokidentifierare. Om ids_to_sort är None, kommer alla bokidentifierare att returneras.

fälten måste vara en lista med 2-tupler av formatet (field_name, ascending=True eller False). Det signifikantaste fältet är den första 2-tupeln.

notes_data_for(field, item_id) → str

Returnera all anteckningsdata som ett diktat eller inget om anteckningen inte finns

notes_for(field, item_id) → str

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

notes_resources_used_by(field, item_id)

Returnera uppsättningen resurs-hashar för alla resurser som används av anteckningen för det angivna posten

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

Returnera värdet för det specifika förvalet eller värdet angivet som standard om ingen inställning är angivet.

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.

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]

Delete the specified extra files, either to Recycle Bin or permanently.

remove_formats(formats_map, db_only=False)

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

Parametrar:

• formats_map – En kartläggning av book_id till en lista med format som ska tas bort från boken.

• db_only – Om True, tas bara handlingen av format från databasen, tar inte bort de aktuella filformaten från filsystemet.

Returnerar:

En karta över bok-id till uppsättning format som faktiskt tagits bort från filsystemet för den boken

remove_items(field, item_ids, restrict_to_book_ids=None)

Ta bort alla poster i det angivna fältet med det angivna id. returnerar uppsättningen av påverkade bok-id. restrict_to_book_ids är en valfri uppsättning bok-id. Om det anges kommer posterna endast att tas 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å post från många-en eller många-många fält som 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 uppsättning bok-id där namnbyte ska utföras, standard för 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äller det angivna formatet från tidigare sparat ORIGINAL_FORMAT, om något. returnerar True vid framgång. The 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 får den ett läslås. Detta är nödvändigt för att förhindra DowngradeLockErrors, som kan hända vid uppdatering av sökcachen i närvaro av sammansatta kolumner. Uppdatering av sökcachen innehåller 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 få ett delat lås. Det kan finnas andra scenarier som utlöser detta också.

Den här egenskapen returnerar ett nytt låsobjekt på varje åtkomst. Detta låsobjekt är inte rekursivt (för prestanda) och får endast användas i ett med satser som with cache.safe_read_lock: annars kommer dåliga saker att hända.

save_original_format(book_id, fmt)

Spara en kopia i det angivna formatet som ORIGINAL_FORMAT, skriver över alla befintliga ORIGINAL_FORMAT.

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

Sök i databasen efter den angivna frågan och returnera en uppsättning matchade bok-id.

Parametrar:

• restriction – En begränsning som är ANDad med angiven förfrågan. Observera att restriktioner lagras i cache, alltså sökandet efter a AND b kommer att vara långsammare än a med restriktion b.

• virtual_fields – Används internt (virtuella fält som on_device ska söka över).

• book_ids – Om inte None, en uppsättning bok-id för vilka böcker kommer att sökas i stället för att söka i 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)

Retur av ett antal noteringar som matchar den angivna heltextsökförfrå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 frågan är tom returneras alla anteckningar.

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

Ställ in alla noteringar för det angivna book_id, fmt, user_type och user.

set_conversion_options(options, fmt='PIPE')

alternativ måste vara en översikt på formen {book_id:conversion_options}

set_cover(book_id_data_map)

Ställ in omslaget för denna bok. Data kan antingen vara en QImage, QPixmap, filobjekt eller bytesträng. Det kan också vara None, i vilket fall eventuellt befintligt omslag tas bort.

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

Ställ in värdena för fältet som anges av namn. Returnerar uppsättningen av alla bok-id som påverkades av ändringen.

Parametrar:

• book_id_to_val_map – Kartläggning av book_ids till värden som bör tillämpas.

• allow_case_change – Om True, i fall det rör sig om många-en eller många-många fält att ändras. Till exempel, om en bok har taggen tag1 och du anger taggen för en annan bok till Tag1 då kommer båda böckerna att ha taggen Tag1 om allow_case_change är True, annars kommer de båda ha 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)

Ställer in länkar för postvärden i fältet. Obs: den här metoden ändrar inte värden som inte finns 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.

Returnerar:

böcker ändras genom att ställa in länken

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

Ställ in metadata för bokens id från Metadata-objektet mi

Inställning force_changes=True tvingar set_metadata att uppdatera fält även om mi innehåller tomma värden. I det här fallet särskiljs ’None’ från ’empty’. Om mi.XXX är None, ersätts inte XXX, annars görs det. Taggar, identifierare och omslagsattribut är specialfall. Taggar och identifierare kan inte ställas in på None så de alltid ersätts 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 har någon effekt på inställning av titel eller författare.

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

Ställ in anteckningsdokumentet. Om den sökbara texten skiljer sig från dokumentet, ange den som searchable_text. Om dokumentet refererar till resurser måste deras hashar finnas i resource_hashes. Ställ in remove_unused_resources till True för att rensa oanvända resurser, notera att uppdatering av en anteckning automatiskt rensar upp resurser som hör till den anteckningen ändå.

set_pref(name, val, namespace=None)

Ställ in den angivna inställningen till det angivna värdet. Se också pref().

split_if_is_multiple_composite(f, val)

Om f är en sammansatt kolumnsökningsnyckel och kolumnen är is_multiple, dela v i unika icke-tomma värden. Jämförelsen är skiftlägeskänslig. Ordningen är inte bevarad. Returnera en list() för kompatibilitet med proxymetadatafältgetters, till exempel taggar.

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

Returnera id av alla böcker som har taggen tagg som är äldre än den angivna tiden. taggjämförelse är skiftlägesoberoende.

Parametrar:

• delta – Ett tidsdeltaobjekt eller None. Om None returneras alla id med taggen.

• must_have_tag – Om inte ingen kommer listan över matchningar att vara begränsad till böcker som har denna tagg

• must_have_authors – En lista över författare. Om inte ingen kommer listan över matchningar att begränsas till böcker som har dessa författare (skiftlägesokänslig).

unretire_note_for(field, item_id) → int

Ta bort en tidigare tillbakadragen anteckning för den angivna posten. Anteckningar tas bort när en post 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 är användbart för en prestandahöjning, i sammanhang där ett ProxyMetadata-objekt för böckerna redan finns. Det bör vara en kartläggning av book_ids till deras motsvarande ProxyMetadata-objekt.

© Copyright Kovid Goyal. Senast uppdaterad den dec. 20, 2024.