Reference for all built-in template language functions

Here, we document all the built-in functions available in the calibre template language. Every function is implemented as a class in python and you can click the source links to see the source code, in case the documentation is insufficient. The functions are arranged in logical groups by type.

Arithmetic

add(x [, y]*)

class calibre.utils.formatter_functions.BuiltinAdd[source]

add(x [, y]*) – returnerar summan av sina argument. Ger ett undantag om ett argument inte är ett tal. Denna funktion kan ofta ersättas med +-operatören.

ceiling(x)

class calibre.utils.formatter_functions.BuiltinCeiling[source]

ceiling(x) – returnerar det minsta heltalet större än eller lika med x. Ger ett undantag om x inte är ett tal.

divide(x, y)

class calibre.utils.formatter_functions.BuiltinDivide[source]

divide(x, y) – returnerar x / y. Ger ett undantag om antingen x eller y inte är siffror. Denna funktion kan ofta ersättas med operatören /.

floor(x)

class calibre.utils.formatter_functions.BuiltinFloor[source]

floor(x) – returnerar det största heltalet mindre än eller lika med x. Ger ett undantag om x inte är ett tal.

fractional_part(x)

class calibre.utils.formatter_functions.BuiltinFractionalPart[source]

fractional_part(x) – returnerar värdet efter decimalpunkten. Till exempel fractional_part(3.14) returnerar 0.14. Ger ett undantag om x inte är ett tal.

mod(x)

class calibre.utils.formatter_functions.BuiltinMod[source]

mod(x) – returneras floor(remainder of x / y). Kasta ett undantag om antingen x eller y inte är ett nummer.

multiply(x [, y]*)

class calibre.utils.formatter_functions.BuiltinMultiply[source]

multiply(x [, y]*) – returnerar produkten av sina argument. Ger ett undantag om något argument inte är ett tal. Denna funktion kan ofta ersättas med operatören *.

round(x)

class calibre.utils.formatter_functions.BuiltinRound[source]

round(x) – returnerar närmaste heltal till x. Ger ett undantag om x inte är ett tal.

subtract(x, y)

class calibre.utils.formatter_functions.BuiltinSubtract[source]

subtract(x, y) – returnerar x - y. Ger ett undantag om antingen x eller y inte är siffror. Denna funktion kan ofta ersättas med operatören -.

Boolean

and(value [, value]*)

class calibre.utils.formatter_functions.BuiltinAnd[source]

and(value [, value]*) – returnerar strängen ”1” om alla värden inte är tomma, annars returneras den tomma strängen. Denna funktion fungerar bra med test eller first_non_empty. Du kan ha så många värden som du vill. I många fall kan &&-operatören ersätta denna funktion.

not (värde)

class calibre.utils.formatter_functions.BuiltinNot[source]

not (värde) – returnerar strängen ”1” om värdet är tomt, annars returneras en tom sträng. Denna funktion fungerar bra med test eller first_non_empty. I många fall kan operatören ! ersätta denna funktion.

or(value [, value]*)

class calibre.utils.formatter_functions.BuiltinOr[source]

or(value [, value]*) – returnerar strängen ”1” om något värde inte är tomt, annars returneras en tom sträng. Denna funktion fungerar bra med test eller first_non_empty. Du kan ha så många värden som du vill. I många fall kan operatören || ersätta denna funktion.

Date functions

date_arithmetic(date, calc_spec, fmt)

class calibre.utils.formatter_functions.BuiltinDateArithmetic[source]

date_arithmetic(date, calc_spec, fmt) – Beräkna ett nytt datum från ’date’ med hjälp av ’calc_spec’. Returnera det nya datumet formaterat enligt valfritt ’fmt’: om det inte tillhandahålls kommer resultatet att vara i iso-format. calc_spec är en sträng som bildas genom att slå samman par av ’vW’ (valueWhat) där ’v’ är ett möjligen negativt tal och W är en av följande bokstäver: s: lägg till ’v’ sekunder till ’date’ m: lägg till ’v’ minuter till ’date’ h: lägg till ’v’ timmar till ’datum’ d: lägg till ’v’ dagar till ’date’ w: lägg till ’v’ veckor till ’data’ y: lägg till ’v’ år till ’date’, där ett år är 365 dagar. Exempel: ’1s3d-1m’ lägger till 1 sekund, lägger till 3 dagar och subtraherar 1 minut från ’data’.

days_between(date1, date2)

class calibre.utils.formatter_functions.BuiltinDaysBetween[source]

days_between(date1, date2) – returnerar antalet dagar mellan date1 och date2. Numret är positivt om date1 är större än date2, annars negativ. Om någon date1 eller date2 inte är datum, returnerar funktionen tomma strängen.

today()

class calibre.utils.formatter_functions.BuiltinToday[source]

today() – returnerar en datumsträng för idag. Detta värde är avsedd för användning i format_date eller days_between, men kan manipuleras som alla andra strängen. Datumet är i ISO format.

Formatting values

finish_formatting(val, fmt, prefix, suffix)

class calibre.utils.formatter_functions.BuiltinFinishFormatting[source]

finish_formatting(val, fmt, prefix, suffix) – tillämpa formatet, prefix och suffix till ett värde på samma sätt som görs i en mall som {series_index: 05.2f | - | -}. Till exempel ger följande program samma resultat som ovanstående mall: program: finish_formatting(field(”series_index”), ”05.2f”, ” - ”, ” - ”)

format_date(val, format_string)

class calibre.utils.formatter_functions.BuiltinFormatDate[source]

format_date(val, format_string) – formaterar värdet, som måste vara ett datum, genom att använda format_string returneras en sträng. Formateringskoderna är: d : dagen som tal utan en inledande nolla (1 till 31) dd: dagen som tal med en inledande nolla (01 till 31) ddd : det förkortade lokaliserade dagnamnet (t.ex. ”mån” till ”sön”). dddd : det långa lokaliserade dagnamnet (t.ex. ”måndag” till ”söndag”). M: månaden som tal utan en inledande nolla (1 till 12). MM: månaden som tal med en inledande nolla (01 till 12) MMM : den förkortade lokaliserade månadens namn (t.ex. ”jan” till ”dec”). MMMM : den långa lokaliserade månadens namn (t.ex. ”januari” till ”december”). yy: året som två siffror (00 till 99). yyyy : året som fyrsiffrigt nummer. h: timmarna utan en inledande 0 (0 till 11 eller 0 till 23, beroende på am/pm) hh: timmarna med en inledande 0 (00 till 11 eller 00 till 23, beroende på am/pm) m: protokollet en utan inledande 0 (0 till 59) mm: minuterna med en inledande 0 (00 till 59) s: sekunderna utan en inledande 0 (0 till 59) ss: sekunderna med en inledande 0 (00 till 59) ap: använd en 12-timmars klocka istället för en 24-timmars klocka, med ”ap” ersatt med den lokaliserade strängen för am eller pm ap: använd en 12-timmars klocka istället för en 24-timmars klocka, med ”ap” ersatt av den lokaliserade strängen för am eller pm iso: datumet med tid och tidszon. Måste vara det enda närvarande formatet to_number: datumet som ett flyttalsnummer from_number[:fmt]: formatera tidsstämpeln med hjälp av fmt om det finns i annat fall iso

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber[source]

format_number(v, template) – format numret v med hjälp av en Python-formateringsmall som ”{0:5.2f}” eller ”{0:,d}” eller ”${0:5,.2f}”. field_name del av mallen ska vara en 0 (noll) ( ”{0:” i exemplen ovan). Se språkmallen och Python-dokumentationen för fler exempel. Du kan lämna den ledande ”{0:” och efterföljande ”}” om mallen innehåller ett format. Returnerar tom sträng om formatering misslyckas.

human_readable(v)

class calibre.utils.formatter_functions.BuiltinHumanReadable[source]

human_readable(v) – returnerar en sträng som representerar antalet v i KB, MB, GB o.s.v.

rating_to_stars(value, use_half_stars)

class calibre.utils.formatter_functions.BuiltinRatingToStars[source]

rating_to_stars(value, use_half_stars) – Returnerar betygsättningen som sträng av stjärntecken. Värdet är ett tal mellan 0 och 5. Ställ in use_half_stars till 1 om du vill ha halvstjärntecken för anpassade betygskolumner som stöder icke-heltalsklassificering, till exempel 2.5.

urls_from_identifiers(identifiers, sort_results)

class calibre.utils.formatter_functions.BuiltinUrlsFromIdentifiers[source]

urls_from_identifiers(identifiers, sort_results) – ger en kommaseparerad lista med identifierare, där en identifierare är ett kolonseparerat värdepar (name:id_value), returnerar en kommaseparerad lista med HTML-URL:er genererade från identifierarna. Listan är inte sorterad om sort_results är 0 (tecken eller nummer), annars sorteras den alfabetiskt efter identifierarens namn. Webbadresserna genereras på samma sätt som kolumnen för inbyggda identifierare när de visas i bokdetaljer.

Get values from metadata

annotation_count()

class calibre.utils.formatter_functions.BuiltinAnnotationCount[source]

annotation_count() – returnera det totala antalet noteringar av alla typer som bifogas den aktuella boken. Den här funktionen fungerar bara i det grafiska gränssnittet.

approximate_formats()

class calibre.utils.formatter_functions.BuiltinApproximateFormats[source]

approximate_formats() – returnerar en kommaseparerad lista över format som vid ett tillfälle var i samband med boken. Det finns ingen garanti för att denna lista är korrekt, även om den antagligen är det. Denna funktion kan anropas i mallprogramläge med mallen ”{:’approximate_formats()’}”. Observera att formatnamnen alltid är versaler, som i EPUB. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda dessa värden på spara-till-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använda den kolumnens värde i din spar/skicka mallar

author_sorts(val_separator)

class calibre.utils.formatter_functions.BuiltinAuthorSorts[source]

author_sorts(val_separator) – returnerar en sträng med en lista med författarens sorteringsvärden för författarna till boken. Sorteringen är ett i författarens metadata (som skiljer sig från den author_sort i böcker). Den återgivna listan har formen författaren sorterings 1 val_separator författare sort 2 o.s.v. Författaren sortera värdena i denna lista är i samma ordning som författarna till boken. Om du vill ha utrymmen runt val_separator sedan inkludera dem i avgränsningssträngen

booksize()

class calibre.utils.formatter_functions.BuiltinBooksize[source]

booksize() – returnerar värdet av storleken fältet. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda detta värde i Save-to-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använda den kolumnens värde i din spara/skicka mallar

connected_device_name(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceName[source]

connected_device_name(storage_location) – om en enhet är ansluten, returnera enhetsnamnet, annars returnera den tomma strängen. Varje lagringsplats på en enhet kan ha olika namn. Platsnamnen är ”main”, ”carda” och ”cardb”. Den här funktionen fungerar bara i det grafiska gränssnittet.

connected_device_uuid(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceUUID[source]

connected_device_uuid(storage_location) – om en enhet är ansluten, returnera enhetens uuid (unikt id), annars returnera den tomma strängen. Varje lagringsplats på en enhet har olika hjälpmedel. Platsnamnen är ”main”, ”carda” och ”cardb”. Denna funktion fungerar endast i det grafiska gränssnittet.

current_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[source]

current_library_name() – returnerar efternamnet på sökvägen till det aktuella calibre-biblioteket. Den här funktionen kan anropas i mallprogramläget med mallen ”{:’current_library_name()’}”.

current_library_path ()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[source]

current_library_path () – returnerar sökvägen till det aktuella calibre-biblioteket. Den här funktionen kan anropas i mallprogramläget med ”{:’current_library_path ()’}”.

current_virtual_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentVirtualLibraryName[source]

current_virtual_library_name() – returnera namnet på det aktuella virtuella biblioteket om det finns ett, annars den tomma strängen. Bibliotekets namn bevaras. Exempel: ”program: current_virtual_library_name()”.

field(lookup_name)

class calibre.utils.formatter_functions.BuiltinField[source]

field(lookup_name) – returnerar metadatafält med namnet efter lookup_name

formats_modtimes(date_format)

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[source]

formats_modtimes(date_format) – returnerar en kommaseparerad lista över kolonseparerade post som representerar modifieringstider för formaten i en bok. Den date_format parametern anger hur datumet ska formateras. Se date_format funktionen för detaljer. Du kan använda funktionen för val för att få modifieringstider för ett visst format. Observera att formatnamn är alltid versaler, som i EPUB.

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths[source]

formats_paths() – returnerar en kommaseparerad lista över kolonseparerade poster som representerar fullständig sökväg till formaten i en bok. Du kan använda markeringsfunktionen för att få sökvägen för ett visst format. Observera att formatnamnen alltid är i versaler, som i EPUB.

formats_sizes()

class calibre.utils.formatter_functions.BuiltinFormatsSizes[source]

formats_sizes() – returnerar en kommaseparerad lista över kolonseparerade poster som representerar storlekar i oktetter av formaten i en bok. Du kan använda select-funktionen för att få storleken för ett visst format. Observera att formatnamn är alltid versaler, som i EPUB.

has_cover ()

class calibre.utils.formatter_functions.BuiltinHasCover[source]

has_cover () – returnera Ja om boken har ett omslag, annars returnera den tomma strängen

is_marked()

class calibre.utils.formatter_functions.BuiltinIsMarked[source]

is_marked() – kontrollera om boken är ’marked’ i calibre. Om det är så returneras värdet på markeringen, antingen ’true’ eller den kommaseparerade listan med namngivna markeringar. Returnerar ’’ om boken inte är markerad.

language_codes(lang_strings)

class calibre.utils.formatter_functions.BuiltinLanguageCodes[source]

language_codes(lang_strings) – returnerar språkkoderna för strängarna som finns i lang_strings. Strängarna ska vara på samma språk som den aktuella platsen. Lang_strings är en kommaseparerad lista.

language_strings(lang_codes, localize)

class calibre.utils.formatter_functions.BuiltinLanguageStrings[source]

language_strings(lang_codes, localize) – returnerar strängarna för språkkoder som finns i lang_codes. Om lokalisera är noll, returneras strängarna på engelska. Om lokalisera inte är noll, returneras strängarna tillbaka på språket på den aktuella platsen. Lang_codes är en kommaseparerad lista.

ondevice()

class calibre.utils.formatter_functions.BuiltinOndevice[source]

ondevice() – returnera Ja om ondevice är inställt, annars returneras den tomma strängen. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda detta värde i Save-to-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använder den kolumnen värde i din spara/skicka mallar

raw_field(lookup_name [, optional_default])

class calibre.utils.formatter_functions.BuiltinRawField[source]

raw_field(lookup_name [, optional_default]) – returnerar metadatafältet med lookup_name utan att använda någon formatering. Det utvärderar och returnerar det valfria andra argumentet ’default’ om fältet är odefinierat (’None’).

raw_list(lookup_name, separator)

class calibre.utils.formatter_functions.BuiltinRawList[source]

raw_list(lookup_name, separator) – returnerar metadatalistan namngiven av lookup_name utan att använda någon formatering eller sortering och med poster avskilda med avgränsare.

series_sort()

class calibre.utils.formatter_functions.BuiltinSeriesSort[source]

series_sort() – returnera seriesorteringsvärde

user_categories()

class calibre.utils.formatter_functions.BuiltinUserCategories[source]

user_categories() – returnerar en kommaseparerad lista över de användarkategorier som den här boken innehåller. Den här funktionen fungerar endast i det grafiska gränssnittet. Om du vill använda dessa värden i mallarna save-to-disk eller send-to-device måste du skapa en anpassad ”kolumn byggd från andra kolumner”, använd funktionen i den kolumnens mall och använda kolumnens värde i dina spara/skicka mallar

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[source]

virtual_libraries() – returnerar en kommaseparerad lista över virtuella bibliotek som innehåller den här boken. Den här funktionen fungerar bara i det grafiska gränssnittet. Om du vill använda dessa värden i mallarna spara-till-disk eller skicka-till-enhet måste du göra en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i kolumnens mall och använda den kolumnens värde i dina spara/skicka mallar

If-then-else

check_yes_no(field_name, is_undefined, is_false, is_true)

class calibre.utils.formatter_functions.BuiltinCheckYesNo[source]

check_yes_no(field_name, is_undefined, is_false, is_true) – kontrollerar värdet på fältet ja/nej som heter genom sökningsnyckelens field_name för ett värde som anges av parametrarna, returnerar ”ja” om en matchning hittas, annars returneras en tom sträng. Ställ in parametern is_undefined, is_false eller is_true till 1 (numret) för att kontrollera det villkoret, annars ställ in till 0. Exempel: check_yes_no(”# bool”, 1, 0, 1) returnerar ”ja” om fältet ja/nej ”#bool” är antingen odefinierad (varken sant eller falskt) eller sant. Mer än en av is_undefined, is_false eller is_true kan ställas in på 1. Den här funktionen används vanligtvis av funktionerna test() eller is_empty().

contains(val, pattern, text if match, text if not match)

class calibre.utils.formatter_functions.BuiltinContains[source]

contains(val, pattern, text if match, text if not match) – kontrollerar om val innehåller träffar för det reguljära uttrycket pattern ”mönster”. Returnerar text if match (”text om matchning”) om träffar hittas annars returneras text if no match (”text om ingen matchning”)

field_exists(field_name)

class calibre.utils.formatter_functions.BuiltinFieldExists[source]

field_exists(field_name) – kontrollerar om ett fält (kolumn) med namnet field_name finns, returnerar ”1” om så är fallet och ”” om inte.

ifempty(val, text if empty)

class calibre.utils.formatter_functions.BuiltinIfempty[source]

ifempty(val, text if empty) – returnerar val om val inte är tom, annars returnera text if empty

test(val, text if not empty, text if empty)

class calibre.utils.formatter_functions.BuiltinTest[source]

test(val, text if not empty, text if empty) – returnerar text if empty om val inte är tomt, annars returneras text if empty

Iterating over values

first_non_empty(value [, value]*)

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[source]

first_non_empty(value [, value]*) – returnerar det första värdet som inte är tomt. Om alla värden är tomma, då returneras den tomma strängen. Du kan ha så många värden som du vill.

lookup(val, [pattern, field,]+ else_field)

class calibre.utils.formatter_functions.BuiltinLookup[source]

lookup(val, [pattern, field,]+ else_field) – som switch, förutom argumenten fält (metadata) namn, inte text. Värdet på lämpligt fält kommer att hämtas och användas. Observera att eftersom sammansatta kolumner är fält, kan du använda denna funktion i ett sammansatt fält och använda värdet av vissa andra sammansatta fältet. Detta är mycket användbart vid konstruerandet av variabla sparvägar

switch(val, [pattern, value,]+ else_value)

class calibre.utils.formatter_functions.BuiltinSwitch[source]

switch(val, [pattern, value,]+ else_value) – för varje pattern, value par, kontrollerar om fältet överensstämmer med det reguljära uttrycket pattern och i så fall returnerar det som`value`. Om inget mönster passar, då returneras else_value. Du kan ha så många pattern, value par som du vill

List lookup

identifier_in_list(val, id, found_val, not_found_val)

class calibre.utils.formatter_functions.BuiltinIdentifierInList[source]

identifier_in_list(val, id, found_val, not_found_val) – behandla val som en lista med identifierare separerade med kommatecken och jämför strängen mot varje värde i listan. En identifierare har formatet ”identifier:value”. ID-parametern ska vara antingen ”id” eller ”id:regexp”. Det första fallet ger träff om det finns någon identifierare med detta ID. Det andra fallet ger träff om regexp matchar identifierarens värde. Om det är en träff, returneras found_val, annars returneras not_found_val.

in_list(val, separator, [ pattern, found_val, ]+ not_found_val)

class calibre.utils.formatter_functions.BuiltinInList[source]

in_list(val, separator, [ pattern, found_val, ]+ not_found_val) – behandla val som en lista med objekt separerade med avgränsare, om mönstret matchar något av listvärdena returneras found_val. Om mönstret inte matchar något listvärde returneras not_found_val. Mönstret och found_value par kan upprepas så många gånger som önskas. Mönstren kontrolleras i ordning. found_val för den första matchningen returneras. Alias: in_list(), list_contains()

list_item(val, index, separator)

class calibre.utils.formatter_functions.BuiltinListitem[source]

list_item(val, index, separator) – tolka värdet som en lista med element åtskilda av separator, returnerar posten index`th. Den första punkten är siffran noll. Den sista komponenten kan returneras med hjälp av `list_item(-1,separator). Om posten inte finns i listan, kommer det tomma värdet returneras. Avgränsaren har samma betydelse som i antal-funktionen.

select(val, key)

class calibre.utils.formatter_functions.BuiltinSelect[source]

select(val, key) – tolka värdet som en kommaseparerad lista med poster, med posterna ”id:värde”. Hitta paret med id lika med tangent och returnera motsvarande värde. Returnerar den tomma strängen om ingen träff hittas.

tr_in_list(val, separator, [string, found_val, ]+ not_found_val)

class calibre.utils.formatter_functions.BuiltinStrInList[source]

tr_in_list(val, separator, [string, found_val, ]+ not_found_val) – behandlar val som en lista med objekt separerade med avgränsare, om strängen matchar något av listvärdena returneras found_val. Om strängen inte matchar något listvärde returneras not_found_val. Jämförelsen är exakt matchning (innehåller inte) och är skiftlägeskänslig. Paren string och found_value kan upprepas så många gånger som önskas. Mönstren kontrolleras i ordning. Found_val för den första matchningen returneras.

List manipulation

count(val, separator)

class calibre.utils.formatter_functions.BuiltinCount[source]

count(val, separator) – tolkar värdet som en lista med element åtskilda av separator, returnerar antalet poster i listan. De flesta listor använder kommatecken som skiljetecken, men författarna använder ett et-tecken. Exempel: {tags:count(,)}, {authors:count(&)}. Alias: count(), list_count()

list_count_matching(list, pattern, separator)

class calibre.utils.formatter_functions.BuiltinListCountMatching[source]

list_count_matching(list, pattern, separator) – tolkar ’list’ som en lista med poster som skiljs åt av ’separator’, returnerar antalet poster i listan som matchar det reguljära uttrycket ’pattern’. Alias: list_count_matching(), count_matching()

list_difference(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListDifference[source]

list_difference(list1, list2, separator) – returnerar en lista genom att ta bort list1 alla post som finns i list2 med en skiftlägeskänslig jämförelse. Posterna i list1 och list2 skiljs åt av avgränsare, liksom posterna i den återgivna listan.

list_equals(list1, sep1, list2, sep2, yes_val, no_val)

class calibre.utils.formatter_functions.BuiltinListEquals[source]

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – returnerar yes_val om list1 och list2 innehåller samma poster, annars returnera no_val. Föremålen bestäms genom att dela upp varje lista med lämpliga avgränsare (sep1 eller sep2). Ordningen på posterna i listorna är inte relevant. Jämförelsen är inte skiftlägeskänslig.

list_intersection(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListIntersection[source]

list_intersection(list1, list2, separator) – returnerar en lista genom att ta bort list1 alla post som finns i list2 med en skiftlägeskänslig jämförelse. Posterna i list1 och list2 skiljs åt av avgränsare, liksom posterna i den återgivna listan.

list_join(with_separator, list1, separator1 [, list2, separator2]*)

class calibre.utils.formatter_functions.BuiltinListJoin[source]

list_join(with_separator, list1, separator1 [, list2, separator2]*) – return a list made by joining the items in the source lists (list1, etc) using with_separator between the items in the result list. Items in each source list[123…] are separated by the associated separator[123…]. A list can contain zero values. It can be a field like publisher that is single-valued, effectively a one-item list. Duplicates are removed using a case-insensitive comparison. Items are returned in the order they appear in the source lists. If items on lists differ only in letter case then the last is used. All separators can be more than one character. Example:

program:

list_join(’#@#’, $authors, ’&’, $tags, ’,’)

Du kan använda list_join på resultaten av tidigare anrop till list_join enligt följande:

program:

a = list_join(’#@#’, $authors, ’&’, $tags, ’,’); b = list_join(’#@#’, a, ’#@#’, $#genre, ’,’, $#people, ’&’)

Du kan använda uttryck för att skapa en lista. Anta till exempel att du vill ha objekt för författare och #genre, men med genren ändrad till ordet ’Genre: ’ följt av den första bokstaven i genren, d.v.s. genren ’Fiction’ blir ’Genre: F’. Följande kommer att göra det:
program:

list_join(’#@#’, $authors, ’&’, list_re($#genre, ’,’, ’^(.).*$’, ’Genre: 1’), ’,’)

list_re(src_list, separator, include_re, opt_replace)

class calibre.utils.formatter_functions.BuiltinListRe[source]

list_re(src_list, separator, include_re, opt_replace) – Konstruera en lista genom att först separera src_list till poster med hjälp av avgränsartecknet. För varje post i listan, kontrollera om det matchar include_re. Om den gör det, sedan lägga till den i listan som ska returneras. Om opt_replace inte är den tomma strängen, tillämpa sedan bytet innan du lägger till posten i den återgivna listan.

list_re_group(src_list, separator, include_re, search_re [, group_template]+)

class calibre.utils.formatter_functions.BuiltinListReGroup[source]

list_re_group(src_list, separator, include_re, search_re [, group_template]+) – Som list_re utom ersättare är inte valfritt. Den använder re_group(list_item, search_re, group_template, …) när du gör ersättare på den resulterande listan.

list_remove_duplicates(list, separator)

class calibre.utils.formatter_functions.BuiltinListRemoveDuplicates[source]

list_remove_duplicates(list, separator) – returnerar en lista som gjorts genom att ta bort dubbletter i källistan. Om poster endast skiljer sig åt i skiftläge, returneras den sista av dem. Posterna i källistan är separerade med avgränsare, liksom posten i den återgivna listan.

list_sort(list, direction, separator)

class calibre.utils.formatter_functions.BuiltinListSort[source]

list_sort(list, direction, separator) – returnera en lista sorterad med en skiftlägesokänslig sortering. Om riktningen är noll sorteras listan stigande, annars fallande. Listposterna skiljs åt med avgränsare, liksom posterna i den återgivna listan.

list_split(list_val, sep, id_prefix)

class calibre.utils.formatter_functions.BuiltinListSplit[source]

list_split(list_val, sep, id_prefix) – delar list_val i separata värden med hjälp av ’sep’ och tilldelar sedan värdena till variabler med namnen ’id_prefix_N’ där N är positionen för värdet i listan. Den första posten har position 0 (noll). Funktionen returnerar det sista elementet i listan. Exempel: split(’one:two:foo’, ’:’, ’var’) motsvarar var_0 = ’one’; var_1 = ’two’; var_2 = ’foo’.

list_union(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListUnion[source]

list_union(list1, list2, separator) – returnerar en lista som görs av en sammanslagning av poster i list1 och list2, ta bort dubbletter med en skiftlägeskänslig jämförelse. Om post skiljer sig i fallet är den i list1 används. Posterna i list1 och list2 skiljs åt av avgränsare, liksom posterna i den återgivna listan. Alias: list_union(), merge_lists()

range(start, stop, step, limit)

class calibre.utils.formatter_functions.BuiltinRange[source]

range(start, stop, step, limit) – returns a list of numbers generated by looping over the range specified by the parameters start, stop, and step, with a maximum length of limit. The first value produced is ’start’. Subsequent values next_v are current_v+step. The loop continues while next_v < stop assuming step is positive, otherwise while next_v > stop. An empty list is produced if start fails the test: start>=stop if step is positive. The limit sets the maximum length of the list and has a default of 1000. The parameters start, step, and limit are optional. Calling range() with one argument specifies stop. Two arguments specify start and stop. Three arguments specify start, stop, and step. Four arguments specify start, stop, step and limit. Examples: range(5) -> ’0,1,2,3,4’. range(0,5) -> ’0,1,2,3,4’. range(-1,5) -> ’-1,0,1,2,3,4’. range(1,5) -> ’1,2,3,4’. range(1,5,2) -> ’1,3’. range(1,5,2,5) -> ’1,3’. range(1,5,2,1) -> error(limit exceeded).

subitems(val, start_index, end_index)

class calibre.utils.formatter_functions.BuiltinSubitems[source]

subitems(val, start_index, end_index) – Den här funktionen används för att bryta isär listor över poster som genrer. Det tolkar värdet som en kommaseparerad lista över poster, där varje post är en period-separerad lista. Returnerar en ny lista genom att först hitta alla period-separerade poster, då för varje sådan post utvinna start_index till end_index komponenter och sedan kombinera resultaten tillbaka tillsammans. Den första komponenten i en periodseparerad lista har ett index på noll. Om ett index är negativ, så det räknas från slutet av listan. Som ett specialfall, är en end_index på noll antas vara längden på listan. Exempel med grundläggande malläge och antar ett #genre värde av ”A.B.C”: {#genre:subitems(0,1)} returnerar ”A”. {#genre:subitems(0,2)} returnerar ”A.B”. {#genre:subitems(1,0)} returnerar ”B.C”. Förutsatt ett #genre värde av ”A.B.C, D.E.F”, {#genre:subitems(0,1)} returnerar ”A, D”. {#genre:subitems(0,2)} returnerar ”A.B, D.E”

sublist(val, start_index, end_index, separator)

class calibre.utils.formatter_functions.BuiltinSublist[source]

sublist(val, start_index, end_index, separator) – tolka värdet som en lista av element separerade av separator, returnerar en ny lista med post från start_index till end_index. Det första postnumret är noll. Om ett index är negativt räknas det från slutet på listan. Som ett specialfall, om end_index är noll antas det motsvara längden på listan. Exempel på användning av grundläggande malläge och antagandet att (de kommaseparerade) taggkolumnerna innehåller ”A, B, C”: {tags:sublist(0,1,\,)} returnerar ”A”. {tags:sublist(-1,0,\,)} returnerar ”C”. {tags:sublist(0,-1,\,)} returnerar ”A, B”.

Other

arguments(id[=expression] [, id[=expression]]*)

class calibre.utils.formatter_functions.BuiltinArguments[source]

arguments(id[=expression] [, id[=expression]]*) – Används i en lagrad mall för att hämta argumenten som skickats i samtalet. Det både deklarerar och initialiserar lokala variabler, effektiva parametrar. Variablerna är positionella; de får värdet av parametern som ges i samtalet i samma position. Om motsvarande parameter inte tillhandahålls i samtalet tilldelar argumenten variabeln det angivna standardvärdet. Om det inte finns något standardvärde ställs variabeln in på den tomma strängen.

assign(id, val)

class calibre.utils.formatter_functions.BuiltinAssign[source]

assign(id, val) – tilldelar val till id och returnerar sedan val. id måste vara en identifierare, inte ett uttryck. Denna funktion kan ofta ersättas med operatören =.

globals(id[=expression] [, id[=expression]]*)

class calibre.utils.formatter_functions.BuiltinGlobals[source]

globals(id[=expression] [, id[=expression]]*) – Hämtar ”globala variabler” som kan skickas till formateraren. Den både deklarerar och initialiserar lokala variabler med namnen på de globala variablerna som skickats in. Om motsvarande variabel inte tillhandahålls i de skickade globalerna tilldelas den variabeln det angivna standardvärdet. Om det inte finns något standardvärde ställs variabeln in som den tomma strängen.

Recursion

eval(template)

class calibre.utils.formatter_functions.BuiltinEval[source]

eval(template) – utvärderar mallen, sänder de lokala variablerna (de ’assign’ed till) istället för bokens metadata. Detta möjliggör användning av mallprocessorn för att konstruera komplexa resultat från lokala variabler. Eftersom {- and }-tecken är speciella, måste du använda [[ för {-tecknet och ]] för }-tecknet; de konverteras automatiskt. Observera också att prefix och suffix (|prefix|suffix-syntax) inte kan användas i argumentet för denna funktion när du använder mallprogramläget.

template(x)

class calibre.utils.formatter_functions.BuiltinTemplate[source]

template(x) – utvärderar x som en mall. Utvärderingen görs i sitt eget sammanhang, vilket innebär att variabler inte delas mellan den som anropande och mallutvärderingen. Eftersom tecknen { och } är speciella, måste du använda [[ för {-tecknet och ]] för }-tecknet, och de konverteras automatiskt. Till exempel template(’[[title_sort]]’) kommer att utvärdera mallen {title_sort} och returnera dess värde. Observera också att prefix och suffix (|prefix|suffix-syntax) inte kan användas i argumentet för denna funktion när du använder mallprogramläget.

Relational

cmp(x, y, lt, eq, gt)

class calibre.utils.formatter_functions.BuiltinCmp[source]

cmp(x, y, lt, eq, gt) – jämför x och y efter konvertering av båda till siffror. Returnerar lt om x < y. Returnerar eq om x == y. Annars returneras gt. I många fall kan de numeriska jämförelseoperatörerna (>#, <#, ==# o.s.v.) ersätta denna funktion.

first_matching_cmp(val, [cmp1, result1,]+, else_result)

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[source]

first_matching_cmp(val, [cmp1, result1,]+, else_result) – jämför ”val < cmpN” i sekvens och returnerar resultN för den första jämförelsen som lyckas. Returnerar else_result om ingen jämförelse lyckas. Exempel: first_matching_cmp(10,5,”small”,10,”middle”,15,”large”,”giant”) returnerar ”large”. Samma exempel med ett första värde på 16 returnerar ”giant”.

strcmp(x, y, lt, eq, gt)

class calibre.utils.formatter_functions.BuiltinStrcmp[source]

strcmp(x, y, lt, eq, gt) – gör en skiftlägeskänslig jämförelse av x och y som strängar. Returnerar lt om x < y. Returnerar eq om x == y. Annars returneras gt. I många fall kan de lexikaliska jämförelseoperatorerna (>, <, == o.s.v.) ersätta denna funktion.

strcmpcase(x, y, lt, eq, gt)

class calibre.utils.formatter_functions.BuiltinStrcmpcase[source]

strcmpcase(x, y, lt, eq, gt) – does a case-sensitive comparison of x and y as strings. Returns lt if x < y. Returns eq if x == y. Otherwise returns gt. Note: This is NOT the default behavior used by calibre, for example, in the lexical comparison operators (==, >, <, etc.). This function could cause unexpected results, preferably use strcmp() whenever possible.

String case changes

capitalize(val)

class calibre.utils.formatter_functions.BuiltinCapitalize[source]

capitalize(val) – returnerar värdet av fältet med versaler

lowercase(val)

class calibre.utils.formatter_functions.BuiltinLowercase[source]

lowercase(val) – returnerar värdet i fältet med gemener

titlecase(val)

class calibre.utils.formatter_functions.BuiltinTitlecase[source]

titlecase(val) – returnerar värdet i fältet i titelformat

uppercase(val)

class calibre.utils.formatter_functions.BuiltinUppercase[source]

uppercase(val) – returnerar värdet i fältet med versaler

String manipulation

character(character_name)

class calibre.utils.formatter_functions.BuiltinCharacter[source]

character(character_name) – returnerar tecknet som heter character_name. Till exempel returnerar character(’newline’) ett nyradstecken (’n’). De tecken som stöds är ’newline’, ’return’, ’tab’ och ’backslash’.

re(val, pattern, replacement)

class calibre.utils.formatter_functions.BuiltinRe[source]

re(val, pattern, replacement) – Returnera val efter tillämpning av det reguljära uttrycket. Alla förekomster av pattern ersätts med replacement. Som allt i calibre är dessa Python-kompatibla reguljära uttryck

re_group(val, pattern [, template_for_group]*)

class calibre.utils.formatter_functions.BuiltinReGroup[source]

re_group(val, pattern [, template_for_group]*) – returnera en sträng gjord genom att tillämpa det reguljära uttrycksmönstret på val och ersätta varje matchad instans med strängen beräknad genom att ersätta varje matchad grupp med det värde som returneras av motsvarande mall. Det ursprungliga matchade värdet för gruppen finns som $. I mallprogramläge, som för mallen och eval-funktionerna, använder du [[ för { och ]] för }. Följande exempel i mallprogramläget letar efter serier med mer än ett ord och versaler det första ordet: {series:’re_group($, ”(S* )(.*)”, ”[[$:uppercase()]]”, ”[[$]]”)’}

shorten(val, left chars, middle text, right chars)

class calibre.utils.formatter_functions.BuiltinShorten[source]

shorten(val, left chars, middle text, right chars) – Returnerar en förkortad version av fältet, som består av left chars, tecken från början av fältet, följt av middle text, följt av right chars tecken från slutet av strängen. Left chars och right chars, måste vara heltal. Antag till exempel titeln på boken är Ancient English Laws in the Times of Ivanhoe, och du vill att den ska passa i ett utrymme på högst 15 tecken. Om du använder {title:shorten(9,-,5)}, kommer resultatet att bli Ancient E-anhoe. Om fältets längd är mindre än left chars + right chars + längden på middle text, då kommer fältet att användas intakt. Till exempel titeln The Dome skulle inte ändras.

strcat(a [, b]*)

class calibre.utils.formatter_functions.BuiltinStrcat[source]

strcat(a [, b]*) – kan ta valfritt antal argument. Returnerar strängen som bildats genom att slå samman alla argument

strcat_max(max, string1 [, prefix2, string2]*)

class calibre.utils.formatter_functions.BuiltinStrcatMax[source]

strcat_max(max, string1 [, prefix2, string2]*) – Returnerar en sträng som bildats genom att slå samman argumenten. Det återgivna värdet initialiseras till string1. Prefix, string-par läggs till i slutet av värde så länge den resulterande strängens längd är mindre än max. String1 returneras även om string1 är längre än max. Du kan skicka så många prefix, string-par som du vill.

strlen(a)

class calibre.utils.formatter_functions.BuiltinStrlen[source]

strlen(a) – Returnerar längden av den sträng som skickas som argument

substr(str, start, slut)

class calibre.utils.formatter_functions.BuiltinSubstr[source]

substr(str, start, slut) – returnerar starttecknet till och med sluttecknet i str. Det första tecknet i STR är nollkaraktär. Om slutet är negativt, då det tyder på att för många tecken räknas från höger. Om slutet är noll, indikeras det sista tecknet. Till exempel substr (’12345 ’, 1, 0) returnerar ’2345’, och substr (’12345 ’, 1, -1) returnerar ’234’.

swap_around_articles(val, separator)

class calibre.utils.formatter_functions.BuiltinSwapAroundArticles[source]

swap_around_articles(val, separator) – returnerar valet med artiklar flyttade till slutet. Värdet kan vara en lista, i vilket fall varje medlem av listan behandlas. Om värdet är en lista måste du ange listvärdesseparatorn. Om ingen separator tillhandahålls behandlas värdet som ett enda värde, inte en lista.

swap_around_comma(val)

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[source]

swap_around_comma(val) – givet ett värde av formen ”B, A” returnerar ”A B”. Det här är mest användbart för att konvertera namn i EN, FN-format till FN EN. Om det inte finns något kommatecken returnerar funktionen värdet oförändrat

to_hex(val)

class calibre.utils.formatter_functions.BuiltinToHex[source]

to_hex(val) – returnerar strängen kodad i hex. Det här är användbart när du skapar calibre-webbadresser.

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate[source]

transliterate(a) – Returnerar en sträng i ett latinskt alfabet som bildas genom en tillnärmning av ljudet av orden i källsträngen. Till exempel om källan är ”Фёдор Миха́йлович Достоевский” returnerar funktionen ”Fiodor Mikhailovich Dostoievskii”.

Template database functions

book_count(query, use_vl)

class calibre.utils.formatter_functions.BuiltinBookCount[source]

book_count(query, use_vl) – returnerar antalet böcker som hittats genom att söka efter förfråga. Om use_vl är 0 (noll) ignoreras virtuella bibliotek. Denna funktion kan endast användas i det grafiska användargränssnittet.

book_values(column, query, sep, use_vl)

class calibre.utils.formatter_functions.BuiltinBookValues[source]

book_values(column, query, sep, use_vl) – returnerar en lista över värdena som finns i kolumnen ”kolumn”, separerade med ”sep”, i böckerna som hittas genom att söka efter ”query”. Om use_vl är 0 (noll) ignoreras virtuella bibliotek. Denna funktion kan endast användas i det grafiska användargränssnittet.

other

set_globals(id[=expression] [, id[=expression]]*)

class calibre.utils.formatter_functions.BuiltinSetGlobals[source]

set_globals(id[=expression] [, id[=expression]]*) – Ställer in ”globala variabler” som kan skickas till formateraren. Globalerna ges namnet på det id som skickas in. Värdet på id:t används om inte ett uttryck tillhandahålls.

API of the Metadata objects

The python implementation of the template functions is passed in a Metadata object. Knowing it’s API is useful if you want to define your own template functions.

class calibre.ebooks.metadata.book.base.Metadata(title, authors=('Okänd',), other=None, template_cache=None, formatter=None)[source]

A class representing all the metadata for a book. The various standard metadata fields are available as attributes of this object. You can also stick arbitrary attributes onto this object.

Metadata from custom columns should be accessed via the get() method, passing in the lookup name for the column, for example: ”#mytags”.

Use the is_null() method to test if a field is null.

This object also has functions to format fields into strings.

The list of standard metadata fields grows with time is in STANDARD_METADATA_FIELDS.

Please keep the method based API of this class to a minimum. Every method becomes a reserved field name.

is_null(field)[source]

Return True if the value of field is null in this object. ’null’ means it is unknown or evaluates to False. So a title of _(’Unknown’) is null or a language of ’und’ is null.

Be careful with numeric fields since this will return True for zero as well as None.

Also returns True if the field does not exist.

deepcopy(class_generator=<function Metadata.<lambda>>)[source]

Do not use this method unless you know what you are doing, if you want to create a simple clone of this object, use deepcopy_metadata() instead. Class_generator must be a function that returns an instance of Metadata or a subclass of it.

get_identifiers()[source]

Return a copy of the identifiers dictionary. The dict is small, and the penalty for using a reference where a copy is needed is large. Also, we don’t want any manipulations of the returned dict to show up in the book.

set_identifiers(identifiers)[source]

Set all identifiers. Note that if you previously set ISBN, calling this method will delete it.

set_identifier(typ, val)[source]

If val is empty, deletes identifier of type typ

standard_field_keys()[source]

return a list of all possible keys, even if this book doesn’t have them

custom_field_keys()[source]

return a list of the custom fields in this book

all_field_keys()[source]

All field keys known by this instance, even if their value is None

metadata_for_field(key)[source]

return metadata describing a standard or custom field.

all_non_none_fields()[source]

Return a dictionary containing all non-None metadata fields, including the custom ones.

get_standard_metadata(field, make_copy)[source]

return field metadata from the field if it is there. Otherwise return None. field is the key name, not the label. Return a copy if requested, just in case the user wants to change values in the dict.

get_all_standard_metadata(make_copy)[source]

return a dict containing all the standard field metadata associated with the book.

get_all_user_metadata(make_copy)[source]

return a dict containing all the custom field metadata associated with the book.

get_user_metadata(field, make_copy)[source]

return field metadata from the object if it is there. Otherwise return None. field is the key name, not the label. Return a copy if requested, just in case the user wants to change values in the dict.

set_all_user_metadata(metadata)[source]

store custom field metadata into the object. Field is the key name not the label

set_user_metadata(field, metadata)[source]

store custom field metadata for one column into the object. Field is the key name not the label

remove_stale_user_metadata(other_mi)[source]

Remove user metadata keys (custom column keys) if they don’t exist in ’other_mi’, which must be a metadata object

template_to_attribute(other, ops)[source]

Takes a list [(src,dest), (src,dest)], evaluates the template in the context of other, then copies the result to self[dest]. This is on a best-efforts basis. Some assignments can make no sense.

smart_update(other, replace_metadata=False)[source]

Merge the information in other into self. In case of conflicts, the information in other takes precedence, unless the information in other is NULL.

format_field(key, series_with_index=True)[source]

Returns the tuple (display_name, formatted_value)

to_html()[source]

A HTML representation of this object.

calibre.ebooks.metadata.book.base.STANDARD_METADATA_FIELDS

The set of standard metadata fields.


'''
All fields must have a NULL value represented as None for simple types,
an empty list/dictionary for complex types and (None, None) for cover_data
'''

SOCIAL_METADATA_FIELDS = frozenset((
    'tags',             # Ordered list
    'rating',           # A floating point number between 0 and 10
    'comments',         # A simple HTML enabled string
    'series',           # A simple string
    'series_index',     # A floating point number
    # Of the form { scheme1:value1, scheme2:value2}
    # For example: {'isbn':'123456789', 'doi':'xxxx', ... }
    'identifiers',
))

'''
The list of names that convert to identifiers when in get and set.
'''

TOP_LEVEL_IDENTIFIERS = frozenset((
    'isbn',
))

PUBLICATION_METADATA_FIELDS = frozenset((
    'title',            # title must never be None. Should be _('Unknown')
    # Pseudo field that can be set, but if not set is auto generated
    # from title and languages
    'title_sort',
    'authors',          # Ordered list. Must never be None, can be [_('Unknown')]
    'author_sort_map',  # Map of sort strings for each author
    # Pseudo field that can be set, but if not set is auto generated
    # from authors and languages
    'author_sort',
    'book_producer',
    'timestamp',        # Dates and times must be timezone aware
    'pubdate',
    'last_modified',
    'rights',
    # So far only known publication type is periodical:calibre
    # If None, means book
    'publication_type',
    'uuid',             # A UUID usually of type 4
    'languages',        # ordered list of languages in this publication
    'publisher',        # Simple string, no special semantics
    # Absolute path to image file encoded in filesystem_encoding
    'cover',
    # Of the form (format, data) where format is, e.g. 'jpeg', 'png', 'gif'...
    'cover_data',
    # Either thumbnail data, or an object with the attribute
    # image_path which is the path to an image file, encoded
    # in filesystem_encoding
    'thumbnail',
))

BOOK_STRUCTURE_FIELDS = frozenset((
    # These are used by code, Null values are None.
    'toc', 'spine', 'guide', 'manifest',
))

USER_METADATA_FIELDS = frozenset((
    # A dict of dicts similar to field_metadata. Each field description dict
    # also contains a value field with the key #value#.
    'user_metadata',
))

DEVICE_METADATA_FIELDS = frozenset((
    'device_collections',   # Ordered list of strings
    'lpath',                # Unicode, / separated
    'size',                 # In bytes
    'mime',                 # Mimetype of the book file being represented
))

CALIBRE_METADATA_FIELDS = frozenset((
    'application_id',   # An application id, currently set to the db_id.
    'db_id',            # the calibre primary key of the item.
    'formats',          # list of formats (extensions) for this book
    # a dict of user category names, where the value is a list of item names
    # from the book that are in that category
    'user_categories',
    # a dict of author to an associated hyperlink
    'author_link_map',
))

ALL_METADATA_FIELDS =      SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           USER_METADATA_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS)

# All fields except custom fields
STANDARD_METADATA_FIELDS = SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS)

# Metadata fields that smart update must do special processing to copy.
SC_FIELDS_NOT_COPIED =     frozenset(('title', 'title_sort', 'authors',
                                      'author_sort', 'author_sort_map',
                                      'cover_data', 'tags', 'languages',
                                      'identifiers'))

# Metadata fields that smart update should copy only if the source is not None
SC_FIELDS_COPY_NOT_NULL =  frozenset(('device_collections', 'lpath', 'size', 'comments', 'thumbnail'))

# Metadata fields that smart update should copy without special handling
SC_COPYABLE_FIELDS =       SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS) - \
                           SC_FIELDS_NOT_COPIED.union(
                           SC_FIELDS_COPY_NOT_NULL)

SERIALIZABLE_FIELDS =      SOCIAL_METADATA_FIELDS.union(
                           USER_METADATA_FIELDS).union(
                           PUBLICATION_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS).union(
                           DEVICE_METADATA_FIELDS) - \
                           frozenset(('device_collections', 'formats',
                               'cover_data'))
# these are rebuilt when needed