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.

Aritmetik ¶

add ¶

class calibre.utils.formatter_functions.BuiltinAdd[source]¶

add(x [, y]*) – returnerar summan av dess argument. Utlöser ett undantag om ett argument inte är ett tal. I de flesta fall kan du använda operatorn + istället för den här funktionen.

ceiling ¶

class calibre.utils.formatter_functions.BuiltinCeiling[source]¶

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

divide ¶

class calibre.utils.formatter_functions.BuiltinDivide[source]¶

divide(x, y) – returnerar x / y. Utlöser ett undantag om antingen x eller y inte är tal. Denna funktion kan vanligtvis ersättas av operatorn /.

floor ¶

class calibre.utils.formatter_functions.BuiltinFloor[source]¶

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

fractional_part ¶

class calibre.utils.formatter_functions.BuiltinFractionalPart[source]¶

fractional_part(value) – returnerar den del av värdet som kommer efter decimaltecknet. Till exempel returnerar fractional_part(3.14) 0.14. Utlöser ett undantag om value inte är ett tal.

mod ¶

class calibre.utils.formatter_functions.BuiltinMod[source]¶

mod(värde, y) – returnerar golvet för resten av värde / y. Utlöser ett undantag om antingen värde eller y inte är ett tal.

multiply ¶

class calibre.utils.formatter_functions.BuiltinMultiply[source]¶

multiply(x[, y]*) – returnerar produkten av sina argument. Utlöser ett undantag om något argument inte är ett tal. Denna funktion kan vanligtvis ersättas av operatorn *.

round ¶

class calibre.utils.formatter_functions.BuiltinRound[source]¶

round(value) – returnerar närmaste heltal till value. Utlöser ett undantag om value inte är ett tal.

subtract ¶

class calibre.utils.formatter_functions.BuiltinSubtract[source]¶

subtract(x, y) – returnerar x - y. Utlöser ett undantag om antingen x eller y inte är tal. Denna funktion kan vanligtvis ersättas av operatorn -.

Booleskt ¶

and ¶

class calibre.utils.formatter_functions.BuiltinAnd[source]¶

and(value [, value]*) – returnerar strängen '1' om alla värden inte är tomma, annars returnerar den den tomma strängen. Du kan ha så många värden du vill. I de flesta fall kan du använda operatorn && istället för den här funktionen. En anledning att inte ersätta and() med && är när kortslutning kan ändra resultaten på grund av biverkningar. Till exempel kommer och(a='',b=5) alltid att utföra båda tilldelningarna, medan operatorn && inte gör den andra.

not ¶

class calibre.utils.formatter_functions.BuiltinNot[source]¶

not(värde) – returnerar strängen '1' om värdet är tomt, annars returnerar den tomma strängen. Denna funktion kan vanligtvis ersättas med den unära operatorn not (!).

or ¶

class calibre.utils.formatter_functions.BuiltinOr[source]¶

or(värde [, värde]*) – returnerar strängen '1' om något värde inte är tomt, annars returnerar den tomma strängen. Du kan ha så många värden du vill. Denna funktion kan vanligtvis ersättas av operatorn ||. En anledning till att den inte kan ersättas är om kortslutning kommer att ändra resultaten på grund av biverkningar.

Databasfunktioner ¶

annotation_count ¶

class calibre.utils.formatter_functions.BuiltinAnnotationCount[source]¶

annotation_count() – returnerar det totala antalet noteringar av alla typer som är kopplade till den aktuella boken. Den här funktionen fungerar bara i det grafiska gränssnittet och innehållsservern.

approximate_formats ¶

class calibre.utils.formatter_functions.BuiltinApproximateFormats[source]¶

approximate_formats() – returnerar en kommaseparerad lista över format som är associerade med boken. Eftersom listan kommer från calibres databas istället för filsystemet finns det ingen garanti för att listan är korrekt, även om den förmodligen är det. Observera att resulterande formatnamn alltid är versaler, som i EPUB. Funktionen approximate_formats() är mycket snabbare än funktionerna formats_....

Denna funktion fungerar bara i det grafiska gränssnittet. Om du vill använda dessa värden i mallar för att spara till disk eller skicka till enhet måste du skapa en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i den kolumnens mall och använda den kolumnens värde i dina spara-/skicka-mallar.

book_count ¶

class calibre.utils.formatter_functions.BuiltinBookCount[source]¶

book_count(query, use_vl) – returnerar antalet böcker som hittats genom att söka efter query. Om use_vl är 0 (noll) ignoreras virtuella bibliotek. Denna funktion och dess tillhörande book_values() är särskilt användbara vid mallsökningar och stöder sökningar som kombinerar information från många böcker, till exempel att söka efter serier med endast en bok. Den kan inte användas i sammansatta kolumner om inte justeringen allow_template_database_functions_in_composites är inställd på True. Den kan bara användas i det grafiska gränssnittet.

Till exempel använder denna mallsökning denna funktion och dess tillhörande för att hitta alla serier med endast en bok:

Definiera en lagrad mall (med Inställningar → Avancerat → Mallfunktioner) med namnet series_only_one_book (namnet är godtyckligt). Mallen är:
```
program:
    vals = globals(vals='');
    if !vals
        then all_series = book_values('series', 'series:true', ',', 0);
        for series in all_series:
            if book_count('series:="' & series & '"', 0) == 1 then
                vals = list_join(',', vals, ',', series, ',')
            fi
        rof;
        set_globals(vals)
    fi;
    str_in_list(vals, ',', $series, 1, '')
```
Första gången mallen körs (den första boken som kontrolleras) lagrar den resultaten av databassökningarna i en ”global” mallvariabel med namnet ”vals”. Dessa resultat används för att kontrollera efterföljande böcker utan att göra om sökningarna.
Använd den lagrade mallen i en mallsökning:

template:"program: series_only_one_book()#@#:n:1"
Att använda en lagrad mall istället för att lägga in mallen i sökningen eliminerar problem som orsakas av kravet på att använda escape-citationstecken i sökuttryck.

Denna funktion kan endast användas i det grafiska användargränssnittet och innehållsservern.

book_values ¶

class calibre.utils.formatter_functions.BuiltinBookValues[source]¶

book_values(column, query, sep, use_vl) – returnerar en lista över de unika värdena som finns i kolumnen column (ett söknamn), separerade med sep, i de böcker som hittas genom att söka efter query. Om use_vl är 0 (noll) ignoreras virtuella bibliotek. Denna funktion och dess tillhörande book_count() är särskilt användbara vid mallsökningar och stöder sökningar som kombinerar information från många böcker, till exempel att söka efter serier med endast en bok. Den kan inte användas i sammansatta kolumner om inte justeringen allow_template_database_functions_in_composites är inställd på True. Denna funktion kan bara användas i det grafiska gränssnittet och innehållsservern.

extra_file_modtime ¶

class calibre.utils.formatter_functions.BuiltinExtraFileModtime[source]¶

extra_file_modtime(file_name, format_string) – returnerar ändringstiden för extrafilen file_name i bokens data/-mapp om den finns, annars -1. Modtime formateras enligt format_string (se format_date() för detaljer). Om format_string är den tomma strängen returneras modtime som flyttal i sekunder sedan epoken. Se även funktionerna has_extra_files(), extra_file_names() och extra_file_size(). Epoken är OS-beroende. Denna funktion kan endast användas i det grafiska gränssnittet och innehållsservern.

extra_file_names ¶

class calibre.utils.formatter_functions.BuiltinExtraFileNames[source]¶

extra_file_names(sep [, pattern]) – returnerar en sep-separerad lista över extra filer i bokens data/-mapp. Om den valfria parametern pattern, ett reguljärt uttryck, anges filtreras listan till filer som matchar pattern. Mönstermatchningen är inte skiftlägeskänslig. Se även funktionerna has_extra_files(), extra_file_modtime() och extra_file_size(). Denna funktion kan endast användas i det grafiska gränssnittet och innehållsservern.

extra_file_size ¶

class calibre.utils.formatter_functions.BuiltinExtraFileSize[source]¶

extra_file_size(file_name) – returnerar storleken i byte på extrafilen file_name i bokens data/-mapp om den finns, annars -1. Se även funktionerna has_extra_files(), extra_file_names() och extra_file_modtime(). Denna funktion kan endast användas i det grafiska gränssnittet och innehållsservern.

formats_modtimes ¶

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[source]¶

formats_modtimes(date_format_string) – returnerar en kommaseparerad lista med kolonseparerade objekt FMT:DATE som representerar ändringstider för formaten i en bok. Parametern date_format_string anger hur datumet ska formateras. Se funktionen format_date() för mer information. Du kan använda funktionen select() för att hämta ändringstiden för ett specifikt format. Observera att formatnamn alltid är versaler, som i EPUB.

formats_path_segments ¶

class calibre.utils.formatter_functions.BuiltinFormatsPathSegments[source]¶

formats_path_segments(with_author, with_title, with_format, with_ext, sep) – return parts of the path to a book format in the calibre library separated by sep. The parameter sep should usually be a slash ('/'). One use is to be sure that paths generated in Save to disk and Send to device templates are shortened consistently. Another is to be sure the paths on the device match the paths in the calibre library.

A book path consists of 3 segments: the author, the title including the calibre database id in parentheses, and the format (author - title). Calibre can shorten any of the three because of file name length limitations. You choose which segments to include by passing 1 for that segment. If you don’t want a segment then pass 0 or the empty string for that segment. For example, the following returns just the format name without the extension:

formats_path_segments(0, 0, 1, 0, '/')

Because there is only one segment the separator is ignored.

If there are multiple formats (multiple extensions) then one of the extensions will be picked at random. If you care about which extension is used then get the path without the extension then add the desired extension to it.

Examples: Assume there is a book in the calibre library with an epub format by Joe Blogs with title ’Help’. It would have the path

Joe Blogs/Help - (calibre_id)/Help - Joe Blogs.epub

The following shows what is returned for various parameters:

formats_path_segments(0, 0, 1, 0, '/') returns Help - Joe Blogs
formats_path_segments(0, 0, 1, 1, '/') returns Help - Joe Blogs.epub
formats_path_segments(1, 0, 1, 1, '/') returns Joe Blogs/Help - Joe Blogs.epub
formats_path_segments(1, 0, 1, 0, '/') returns Joe Blogs/Help - Joe Blogs
formats_path_segments(0, 1, 0, 0, '/') returns Help - (calibre_id)

Visar dokumentationen på engelska på grund av FFML-felet: Missing [*] in list near text:”” on line 22 in ”formats_path_segments”

formats_paths ¶

class calibre.utils.formatter_functions.BuiltinFormatsPaths[source]¶

formats_paths([separator]) – returnerar en separator-separerad lista över kolonseparerade objekt FMT:PATH som anger den fullständiga sökvägen till formaten för en bok. Argumentet separator är valfritt. Om det inte anges är separatorn ', ' (kommamellanslag). Om separatorn är ett komma kan du använda funktionen select() för att hämta sökvägen för ett specifikt format. Observera att formatnamn alltid är versaler, som i EPUB.

formats_sizes ¶

class calibre.utils.formatter_functions.BuiltinFormatsSizes[source]¶

formats_sizes() – returnerar en kommaseparerad lista med kolonseparerade FMT:SIZE-element som anger storleken på formaten för en bok i byte. Du kan använda funktionen select() för att hämta storleken för ett specifikt format. Observera att formatnamn alltid är versaler, som i EPUB.

get_link ¶

class calibre.utils.formatter_functions.BuiltinGetLink[source]¶

get_link(field_name, field_value) – hämta länken för fältet field_name med värdet field_value. Om det inte finns någon bifogad länk, returnera den tomma strängen. Exempel:

Följande returnerar länken som är bifogad till taggen Fiction:
```
get_link('tags', 'Fiction')
```

Denna mall skapar en lista över länkarna för alla taggar som är associerade med en bok i formen value:link, ...:

program:
    ans = '';
    for t in $tags:
        l = get_link('tags', t);
        if l then
            ans = list_join(', ', ans, ',', t & ':' & get_link('tags', t), ',')
        fi
    rof;
ans

Denna funktion fungerar bara i det grafiska gränssnittet och innehållsservern.

get_note ¶

class calibre.utils.formatter_functions.BuiltinGetNote[source]¶

get_note(field_name, field_value, plain_text) – hämta anteckningen för fältet field_name med värdet field_value. Om plain_text är tom, returnera anteckningens HTML inklusive bilder. Om plain_text är 1 (eller '1'), returnera anteckningens klartext. Om anteckningen inte finns, returnera den tomma strängen i båda fallen. Exempel:

Returnera HTML-koden för anteckningen som är kopplad till taggen Fiction:
```
program:
get_note('taggar', 'Fiction', '')
```
Returnera den klara texten för anteckningen som är kopplad till författaren Isaac Asimov:
```
program:
    get_note('authors', 'Isaac Asimov', 1)
```

Denna funktion fungerar endast i det grafiska gränssnittet och innehållsservern.

has_extra_files ¶

class calibre.utils.formatter_functions.BuiltinHasExtraFiles[source]¶

has_extra_files([pattern]) – returnerar antalet extra filer, annars ’’ (den tomma strängen). Om den valfria parametern pattern (ett reguljärt uttryck) anges filtreras listan till filer som matchar pattern innan filerna räknas. Mönstermatchningen är inte skiftlägeskänslig. Se även funktionerna extra_file_names(), extra_file_size() och extra_file_modtime(). Denna funktion kan endast användas i det grafiska gränssnittet och innehållsservern.

has_note ¶

class calibre.utils.formatter_functions.BuiltinHasNote[source]¶

has_note(field_name, field_value). Kontrollera om ett fält har en anteckning. Denna funktion har två varianter:

om field_value inte är '' (den tomma strängen) returnera '1' om värdet field_value i fältet field_name har en anteckning, annars ''.

Exempel: has_note('tags', 'Fiction') returnerar '1' om taggen fiction har en bifogad anteckning, annars ''.
Om field_value är '' returnerar du en lista med värden i field_name som har en anteckning. Om inget objekt i fältet har en anteckning returnerar du ''. Denna variant är användbar för att visa kolumnikoner om något värde i fältet har en anteckning, snarare än ett specifikt värde.

Exempel: has_note('authors', '') returnerar en lista över författare som har anteckningar, eller '' om ingen författare har en anteckning.

Du kan testa om alla värden i field_name har en anteckning genom att jämföra listlängden för den här funktionens returvärde med listlängden för värdena i field_name. Exempel:

list_count(has_note('authors', ''), '&') ==# list_count_field('authors')

Denna funktion fungerar bara i det grafiska gränssnittet och innehållsservern.

reading_progress ¶

class calibre.utils.formatter_functions.BuiltinReadingProgress[source]¶

reading_progress(book_id, [user, output_fmt, which, fmt]) – returnerar läsförloppet i det angivna utmatningsformatet.Parametern user matchar som standard vilken användare som helst. Använd värdet local för att matcha läsförloppet i calibre e-bokvisaren. Använd _ för att matcha läsförloppet för anonyma användare av visaren för innehållsservern. Alla andra värden matchar motsvarande användarnamn som används i innehållsservern.

Parametern output_fmt styr formatet på texten som returneras av denna funktion. Den tar tre värden:

page_count - standardvärdet, matar ut lästa sidor / totalt antal sidor. Om sidräkning inte är aktiverat matas istället ut procent läst.
percent - matar ut procent läst
pos_frac - matar ut en bråkdel mellan noll och ett.

Parametern which styr hur den specifika läsförloppsposten för den angivna user väljs. Det kan finnas mer än en post om ingen användare anges eller om boken har lästs i flera format eller på flera enheter. Den accepterar två värden:

most_recent - förloppet för den senaste läsaren av boken (standardvärdet)
furthest - det längsta förloppet för alla matchande poster

Parametern fmt styr vilket bokformat som används. Standardvärdet är att returnera poster för alla format, den specifika posten väljs sedan av parametern which.

Några exempel:

{id:reading_progress()} -- läsförloppet som lästa sidor / totalt antal sidor
                           för den senaste lässessionen av den här boken
{id:reading_progress(,percent)} -- samma som ovan, men som en procentandel
{id:reading_progress(,pos_frac,furthest)} -- samma som ovan, men som en bråkdel och med
                                             längsta förloppet i den här boken.
{id:reading_progress(bob,pos_frac,furthest,EPUB)} -- för användaren "bob" och "EPUB-formatet

Datumfunktioner ¶

date_arithmetic ¶

class calibre.utils.formatter_functions.BuiltinDateArithmetic[source]¶

date_arithmetic(value, calc_spec, fmt) – Beräkna ett nytt datum från value med calc_spec. Returnerar det nya datumet formaterat enligt det valfria fmt: om det inte anges kommer resultatet att vara i ISO-format. calc_spec är en sträng som bildas genom att sammanfoga par av vW (valueWhat) där v är ett eventuellt 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 date
d: lägg till v dagar till date
w: lägg till v veckor till date
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 date.

days_between ¶

class calibre.utils.formatter_functions.BuiltinDaysBetween[source]¶

dagar_between(datum1, datum2) – returnerar antalet dagar mellan datum1 och datum2. Talet är positivt om datum1 är större än datum2, annars negativt. Om antingen datum1 eller datum2 inte är datum returnerar funktionen den tomma strängen.

today ¶

class calibre.utils.formatter_functions.BuiltinToday[source]¶

today() – returnerar en datum+tid-sträng för idag (nu). Detta värde är utformat för användning i format_datum eller days_between, men kan manipuleras som vilken annan sträng som helst. Datumet är i ISO datum/tid-format.

Formaterar värden ¶

f_string ¶

class calibre.utils.formatter_functions.BuiltinFString[source]¶

f_string(string) – tolka string på samma sätt som Python tolkar f-strängar. Den avsedda användningen är att förenkla långa sekvenser av str & str eller strcat(a,b,c)-uttryck.

Text mellan klammerparenteser ({ och }) måste vara malluttryck i allmänt programläge. Uttrycken, som kan vara uttryckslistor, utvärderas i det aktuella sammanhanget (aktuell bok och lokala variabler). Text som inte är mellan klammerparenteser skickas igenom oförändrad.

Exempel:

f_string('Här är titeln: {$title}') - returnerar strängen med {$title} ersatt med titeln på den aktuella boken. Om till exempel bokens titel är 20 000 ligor under havet returnerar f_string() Här är titeln: 20 000 ligor under havet.
Om det aktuella datumet är den 18 september 2025, returnerar denna f_string()
```
f_string("Dagens datum: {d = today(); format_date(d, 'd')} av {format_date(d, 'MMMM')}, {format_date(d, 'yyyy')}")
```
strängen Dagens datum: den 18 september 2025. Observera uttryckslistan (en tilldelning sedan ett if-uttryck) som används i den första { ... }-gruppen för att tilldela dagens datum till en lokal variabel.

Om boken är bok #3 i en serie med namnet Foo som har 5 böcker, då returnerar denna mall

program:
    if $series then
        series_count = book_count('series:"""=' & $series & '"""', 0);
        returnera f_string("{$series}, bok {$series_index} av {series_count}")
    fi;
    return 'Denna bok ingår inte i en serie'

returnerar Foo, bok 3 av 5

finish_formatting ¶

class calibre.utils.formatter_functions.BuiltinFinishFormatting[source]¶

finish_formatting(value, format, prefix, suffix) – tillämpa format, prefix och suffix på value på samma sätt som i en mall som {series_index:05.2f| - |- }. Denna funktion tillhandahålls för att underlätta konvertering av komplexa mallar med en enda funktion eller mallprogramläge till GPM-mallar. Till exempel producerar följande program samma utdata som mallen ovan:

program: finish_formatting(field("series_index"), "05.2f", " - ", " - ")

Ett annat exempel: för mallen:

{series:re(([^\s])[^\s]+(\s|$),\1)}{series_index:0>2s| - | - }{title}

använd:

program:
    strcat(
        re(fält('serie'), '([^\s])[^\s]+(\s|$)', '\1'),
        finish_formatting(fält('serieindex'), '0>2s', ' - ', ' - '),
        field('title')
    )

format_date ¶

class calibre.utils.formatter_functions.BuiltinFormatDate[source]¶

format_date(value, format_string) – formatera value, som måste vara en datumsträng, med format_string, vilket returnerar en sträng. Det är bäst om datumet är i ISO-format eftersom användning av andra datumformat ofta orsakar fel eftersom det faktiska datumvärdet inte kan bestämmas entydigt. Observera att funktionen format_date_field() är både snabbare och mer tillförlitlig.

Formateringskoderna är: [LISTA]

format_date_field ¶

class calibre.utils.formatter_functions.BuiltinFormatDateField[source]¶

format_date_field(field_name, format_string) – formaterar värdet i fältet field_name, vilket måste vara söknamnet för ett datumfält, antingen standard eller anpassat. Se format_date() för formateringskoder. Den här funktionen är mycket snabbare än format_date() och bör användas när du formaterar värdet i ett fält (kolumn). Den är också mer tillförlitlig eftersom den fungerar direkt på det underliggande datumet. Den kan inte användas för beräknade datum eller datum i strängvariabler. Exempel:

format_date_field('pubdate', 'åååå.MM.dd')
format_date_field('#date_read', 'MMM dd, åååå')

format_duration ¶

class calibre.utils.formatter_functions.BuiltinFormatDuration[source]¶

format_duration(värde, mall, [största_enhet]) – formaterar värdet, ett antal sekunder, till en sträng som visar veckor, dagar, timmar, minuter och sekunder. Om värdet är ett flyttal avrundas det till närmaste heltal. Du väljer hur du formaterar värdet med hjälp av en mall som består av värdeväljare omgivna av [ och ] tecken. Väljarna är:

[w]: veckor
[d]: dagar
[h]: timmar
[m]: minuter
[s]: sekunder

Du kan lägga in godtycklig text mellan väljare.

Följande exempel använder en varaktighet på 2 dagar (172 800 sekunder), 1 timme (3 600 sekunder) och 20 sekunder, vilket totalt blir 176 420 sekunder.

[LISTA]

format_number ¶

class calibre.utils.formatter_functions.BuiltinFormatNumber[source]¶

format_number(värde, mall) – tolkar värdet som ett tal och formaterar det talet med hjälp av en Python-formateringsmall som {0:5.2f} eller {0:,d} eller ${0:5,.2f}. Formateringsmallen måste börja med {0: och sluta med } som i exemplen ovan. Undantag: du kan utelämna det inledande ”{0:” och det efterföljande ”}” om formatmallen bara innehåller ett format. Se Template Language och Python-dokumentationen för fler exempel. Returnerar den tomma strängen om formateringen misslyckas.

human_readable ¶

class calibre.utils.formatter_functions.BuiltinHumanReadable[source]¶

human_readable(value) – förväntar sig att value är ett tal och returnerar en sträng som representerar det talet i KB, MB, GB, etc.

rating_to_stars ¶

class calibre.utils.formatter_functions.BuiltinRatingToStars[source]¶

rating_to_stars(value, use_half_stars) – Returnerar value som en sträng med stjärntecken (★). Värdet måste vara ett tal mellan 0 och 5. Sätt use_half_stars till 1 om du vill ha halvstjärntecken för bråktal som är tillgängliga med anpassade betygskolumner.

Grafiska användargränssnittsfunktioner ¶

selected_books ¶

class calibre.utils.formatter_functions.BuiltinSelectedBooks[source]¶

selected_books([sorted_by, ascending]) – returnerar en lista med bok-ID:n i urvalsordning för de böcker som för närvarande är valda.

Denna funktion kan endast användas i det grafiska gränssnittet.

selected_column ¶

class calibre.utils.formatter_functions.BuiltinSelectedColumn[source]¶

selected_column() – returnerar söknamnet på kolumnen som innehåller den valda cellen. Den returnerar '' om ingen cell är vald.

Denna funktion kan endast användas i det grafiska användargränssnittet.

show_dialog ¶

class calibre.utils.formatter_functions.BuiltinShowDialog[source]¶

show_dialog(html_or_text) – visar en dialogruta som innehåller html-koden eller texten. Funktionen returnerar '1''' om användaren trycker på OK,’’’’ om Avbryt.

Denna funktion kan endast användas i det grafiska gränssnittet.

sort_book_ids ¶

class calibre.utils.formatter_functions.BuiltinSortBookIds[source]¶

``sort_book_ids(book_ids, sorted_by, ascending [, sorted_by, ascending]*)’’ – Returnerar listan över bok-ID sorterade efter kolumnen som anges av söknamnet i``sorted_by’’ i den ordning som anges av ``ascending’’. Om``ascending’’ är ``1’’ sorteras böckerna efter värdet i kolumnen ’sorted_by’ i stigande ordning, annars i fallande ordning. Du kan ha flera par av``sorted_by, ascending’’. Det första paret anger huvudordningen.

Denna funktion kan endast användas i det grafiska gränssnittet.

width_from_pages ¶

class calibre.utils.formatter_functions.BuiltinWidthFromPages[source]¶

width_from_pages(value [, num_of_pages_for_max_width, logarithmic_factor, default_width]) – returnerar bredden på bokryggen som en bråkdel mellan '0' och '1' givet ett givet antal sidor. Detta används för att beräkna bredden på ryggen i bokhyllavyn, från ett sidantal. De valfria argumenten styr hur bredden beräknas.

num_of_pages_for_max_width – styr de bredaste böckerna, alla böcker med minst det angivna antalet sidor ges bredd 1. Standardinställningen är 1500.
logarithmic_factor – styr hur snabbt bredden varierar när sidorna sträcker sig från 0 till det maximala. Standardinställningen är 2.
default_width – är bredden för böcker med ett ogiltigt antal sidor.

Hämta värden från metadata ¶

author_links ¶

class calibre.utils.formatter_functions.BuiltinAuthorLinks[source]¶

author_links(val_separator, pair_separator) – returnerar en sträng som innehåller en lista över författare och dessa författares länkvärden i formen: author1 val_separator author1_link pair_separator author2 val_separator author2_link etc.

En författare separeras från sitt länkvärde med strängen val_separator utan tillagda mellanslag. Om man antar att val_separator är ett kolon, separeras author:link value-par med strängargumentet pair_separator utan tillagda mellanslag. Det är upp till dig att välja avgränsare som inte förekommer i författarnamn eller länkar. En författare inkluderas även om författarlänken är tom.

author_sorts ¶

class calibre.utils.formatter_functions.BuiltinAuthorSorts[source]¶

author_sorts(val_separator) – returnerar en sträng som innehåller en lista med författarens sorteringsvärden för bokens författare. Sorteringen är den som finns i författarmetadatainformationen, vilken kan skilja sig från author_sort i böcker. Den returnerade listan har formen author sort 1 val_separator author sort 2 etc. utan tillagda mellanslag. Författarsorteringsvärdena i den här listan är i samma ordning som bokens författare. Om du vill ha mellanslag runt val_separator, inkludera dem i strängen val_separator.

booksize ¶

class calibre.utils.formatter_functions.BuiltinBooksize[source]¶

booksize() – returnerar värdet för calibre size-fältet. Returnerar ’’ om boken inte har några format.

Denna funktion fungerar bara i det grafiska gränssnittet. Om du vill använda detta värde i mallar för att spara till disk eller skicka till enhet måste du skapa en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i den kolumnens mall och använda den kolumnens värde i dina spara-/skicka-mallar.

connected_device_name ¶

class calibre.utils.formatter_functions.BuiltinConnectedDeviceName[source]¶

connected_device_name(storage_location_key) – om en enhet är ansluten returneras enhetsnamnet, annars returneras den tomma strängen. Varje lagringsplats på en enhet har sitt eget enhetsnamn. Namnen på storage_location_key är 'main', 'carda' och 'cardb'. Den här funktionen fungerar bara i det grafiska gränssnittet.

connected_device_uuid ¶

class calibre.utils.formatter_functions.BuiltinConnectedDeviceUUID[source]¶

connected_device_uuid(storage_location_key) – om en enhet är ansluten returneras enhetens uuid (unikt id), annars returneras den tomma strängen. Varje lagringsplats på en enhet har en annan uuid. Platsnamnen för storage_location_key är 'main', 'carda' och 'cardb'. Den här funktionen fungerar bara i det grafiska gränssnittet.

current_library_name ¶

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[source]¶

current_library_name() – returnerar det sista namnet på sökvägen till det aktuella calibre-biblioteket.

current_library_path ¶

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[source]¶

current_library_path() – returnerar den fullständiga sökvägen till det aktuella calibre-biblioteket.

current_virtual_library_name ¶

class calibre.utils.formatter_functions.BuiltinCurrentVirtualLibraryName[source]¶

current_virtual_library_name() – returnerar namnet på det aktuella virtuella biblioteket om det finns ett, annars är den tomma strängen. Biblioteksnamnet bevaras med gemener och versaler. Exempel:

program: current_virtual_library_name()

Denna funktion fungerar bara i det grafiska gränssnittet.

field ¶

class calibre.utils.formatter_functions.BuiltinField[source]¶

field(lookup_name) – returnerar värdet för metadatafältet med söknamnet lookup_name. Prefixet $ kan användas istället för funktionen, som i $tags.

has_cover ¶

class calibre.utils.formatter_functions.BuiltinHasCover[source]¶

has_cover() – returnerar 'Yes' om boken har ett omslag, annars den tomma strängen.

is_marked ¶

class calibre.utils.formatter_functions.BuiltinIsMarked[source]¶

is_marked() – check whether the book is marked in calibre. If it is then return the value of the mark, either 'true' (lower case) or a comma-separated list of named marks. Returns '' (the empty string) if the book is not marked. This function works only in the GUI.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”is_marked”

language_codes ¶

class calibre.utils.formatter_functions.BuiltinLanguageCodes[source]¶

language_codes(lang_strings) – returnerar språkkoderna för språknamnen som skickas i lang_strings. Strängarna måste vara på språket för den aktuella språkinställningen. lang_strings är en kommaseparerad lista.

language_strings ¶

class calibre.utils.formatter_functions.BuiltinLanguageStrings[source]¶

language_strings(value, localize) – returnerar språknamnen för språkkoderna (se här för namn och koder) som skickats i value. Exempel: {languages:language_strings()}. Om localize är noll, returnerar strängarna på engelska. Om localize inte är noll, returnerar strängarna på språket för den aktuella lokalen. lang_codes är en kommaseparerad lista.

ondevice ¶

class calibre.utils.formatter_functions.BuiltinOndevice[source]¶

ondevice() – returnera strängen 'Ja' om ondevice är satt, annars returnera den tomma strängen. Den här funktionen fungerar bara i det grafiska gränssnittet. Om du vill använda det här värdet i mallar för att spara till disk eller skicka till enhet måste du skapa en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i den kolumnens mall och använda den kolumnens värde i dina spara-/skicka-mallar.

raw_field ¶

class calibre.utils.formatter_functions.BuiltinRawField[source]¶

raw_field(lookup_name [, optional_default]) – returnerar metadatafältet namngivet av lookup_name utan att tillämpa någon formatering. Den utvärderar och returnerar det valfria andra argumentet optional_default om fältets värde är odefinierat (None). Prefixet $$ kan användas istället för funktionen, som i $$pubdate.

raw_list ¶

class calibre.utils.formatter_functions.BuiltinRawList[source]¶

raw_list(lookup_name, separator) – returnerar metadatalistan namngiven med lookup_name utan att tillämpa någon formatering eller sortering, med objekten separerade med separator.

series_sort ¶

class calibre.utils.formatter_functions.BuiltinSeriesSort[source]¶

series_sort() – returnerar seriens sorterade värden.

user_categories ¶

class calibre.utils.formatter_functions.BuiltinUserCategories[source]¶

user_categories() – returnerar en kommaseparerad lista över användarkategorierna 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 mallar för att spara till disk eller skicka till enhet måste du skapa en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i den kolumnens mall och använda den 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 mallar för att spara till disk eller skicka till enhet måste du skapa en anpassad Kolumn byggd från andra kolumner, använda funktionen i den kolumnens mall och använda den kolumnens värde i dina spara-/skicka-mallar.

Iterera över värden ¶

first_non_empty ¶

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[source]¶

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

lookup ¶

class calibre.utils.formatter_functions.BuiltinLookup[source]¶

lookup(value, [ pattern, key, ]* else_key) – Mönstren kontrolleras mot value i ordning. Om ett pattern matchar returneras värdet för fältet namngivet av key. Om inget mönster matchar returneras värdet för fältet namngivet av else_key. Se även funktionen switch().

switch ¶

class calibre.utils.formatter_functions.BuiltinSwitch[source]¶

switch(value, [patternN, valueN,]+ else_value) – for each patternN, valueN pair, checks if the value matches the regular expression patternN and if so returns the associated valueN. If no patternN matches, then else_value is returned. You can have as many patternN, valueN pairs as you wish. The first match is returned.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”switch”

switch_if ¶

class calibre.utils.formatter_functions.BuiltinSwitchIf[source]¶

switch_if([test_expression, value_expression,]+ else_expression) – for each test_expression, value_expression pair, checks if test_expression is True (non-empty) and if so returns the result of value_expression. If no test_expression is True then the result of else_expression is returned. You can have as many test_expression, value_expression pairs as you want.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”switch_if”

Listmanipulation ¶

list_count ¶

class calibre.utils.formatter_functions.BuiltinCount[source]¶

list_count(value, separator) – tolkar värdet som en lista med objekt separerade med separator och returnerar antalet objekt i listan. De flesta listor använder ett kommatecken som separator, men authors använder ett et-tecken (&).

Exempel: {tags:list_count(,)}, {authors:list_count(&)}.

Alias: count(), list_count()

list_count_field ¶

class calibre.utils.formatter_functions.BuiltinFieldListCount[source]¶

list_count_field(lookup_name)– returnerar antalet objekt i fältet med söknamnet lookup_name. Fältet måste ha flera värden, till exempel authors eller tags, annars genererar funktionen ett fel. Den här funktionen är mycket snabbare än list_count() eftersom den arbetar direkt på calibre-data utan att först konvertera den till en sträng. Exempel: list_count_field('tags').

list_count_matching ¶

class calibre.utils.formatter_functions.BuiltinListCountMatching[source]¶

list_count_matching(value, pattern, separator) – tolkar value som en lista med objekt separerade med separator, och returnerar antalet objekt i listan som matchar det reguljära uttrycket pattern.

Alias: list_count_matching(), count_matching()

list_difference ¶

class calibre.utils.formatter_functions.BuiltinListDifference[source]¶

list_difference(list1, list2, separator) – returnerar en lista som skapas genom att ta bort alla objekt som finns i list2 från list1 med hjälp av en skiftlägesoberoende jämförelse. Objekten i list1 och list2 separeras med separator, liksom objekten i den returnerade listan.

list_equals ¶

class calibre.utils.formatter_functions.BuiltinListEquals[source]¶

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – returnera yes_val om list1 och list2 innehåller samma objekt, annars returnera no_val. Objekten bestäms genom att dela varje lista med lämpligt avgränsningstecken (sep1 eller sep2). Ordningen på objekten i listorna är inte relevant. Jämförelsen är inte skiftlägeskänslig.

list_intersection ¶

class calibre.utils.formatter_functions.BuiltinListIntersection[source]¶

list_intersection(list1, list2, separator) – returnerar en lista som skapas genom att ta bort alla objekt från list1 som inte finns i list2 med hjälp av en skiftlägesoberoende jämförelse. Objekten i list1 och list2 separeras med separator, liksom objekten i den returnerade listan.

list_join ¶

class calibre.utils.formatter_functions.BuiltinListJoin[source]¶

list_join(with_separator, list1, separator1 [, list2, separator2]*) – returnerar en lista som skapats genom att sammanfoga objekten i källistorna (list1 etc) med hjälp av with_separator mellan objekten i resultatlistan. Objekten i varje käll-list[123...] separeras med den associerade separatorn[123...]. En lista kan innehålla nollvärden. Det kan vara ett fält som publisher som har ett enda värde, i praktiken en lista med ett objekt. Dubbletter tas bort med hjälp av en skiftlägesoberoende jämförelse. Objekt returneras i den ordning de visas i källistorna. Om objekt på listor bara skiljer sig åt i versaler används det sista. Alla avgränsare kan bestå av mer än ett tecken.

Exempel:

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, '&', 'some value', ',')

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

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

list_re ¶

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 i objekt med hjälp av tecknet separator. För varje objekt i listan, kontrollera om det matchar include_re. Om det gör det, lägg till det i listan som ska returneras. Om opt_replace inte är en tom sträng, tillämpa ersättningen innan posten läggs till i den returnerade listan.

list_re_group ¶

class calibre.utils.formatter_functions.BuiltinListReGroup[source]¶

list_re_group(src_list, separator, include_re, search_re [,template_for_group]*) – Som list_re() förutom att ersättningar inte är valfria. Den använder re_group(item, search_re, template ...) när ersättningarna görs.

list_remove_duplicates ¶

class calibre.utils.formatter_functions.BuiltinListRemoveDuplicates[source]¶

list_remove_duplicates(list, separator) – returnerar en lista skapad genom att ta bort dubbletter av objekt i list. Om objekten bara skiljer sig åt i fallet returneras det sista. Objekten i list separeras med separator, liksom objekten i den returnerade listan.

list_sort ¶

class calibre.utils.formatter_functions.BuiltinListSort[source]¶

list_sort(värde, riktning, avgränsare) – returnerar värde sorterat med en lexikal sortering som inte känsligt för gemener och versaler. Om riktning är noll (tal eller tecken) sorteras värde stigande, annars fallande. Listobjekten separeras med avgränsare, liksom objekten i den returnerade listan.

list_split ¶

class calibre.utils.formatter_functions.BuiltinListSplit[source]¶

list_split(list_val, sep, id_prefix) – delar upp list_val i separata värden med hjälp av sep, och tilldelar sedan värdena till lokala variabler med namnet id_prefix_N där N är värdets position i listan. Det första elementet har position 0 (noll). Funktionen returnerar det sista elementet i listan.

Exempel:

list_split('ett:två:foo', ':', 'var')

är ekvivalent med:

var_0 = 'ett'
    var_1 = 'två'
    var_2 = 'foo'

list_union ¶

class calibre.utils.formatter_functions.BuiltinListUnion[source]¶

list_union(list1, list2, separator) – returnerar en lista skapad genom att sammanfoga objekten i list1 och list2, och ta bort dubbletter med hjälp av en skiftlägesoberoende jämförelse. Om objekten skiljer sig åt i skiftläge används den i list1. Objekten i list1 och list2 separeras med separator, liksom objekten i den returnerade listan.

Alias: merge_lists(), list_union()

range ¶

class calibre.utils.formatter_functions.BuiltinRange[source]¶

range(start, stop, step, limit) – returnerar en lista med tal som genereras genom att loopa över det område som anges av parametrarna start, stop och step, med en maximal längd på limit. Det första värdet som produceras är ’start’. Efterföljande värden next_v = current_v + step. Loopen fortsätter medan next_v < stop antar att step är positiv, annars medan next_v > stop. En tom lista produceras om start misslyckas med testet: start >= stop om step är positiv. limit anger listans maximala längd och har ett standardvärde på 1000. Parametrarna start, step och limit är valfria. Att anropa range() med ett argument anger stop. Två argument anger start och stop. Tre argument anger start, stop och step. Fyra argument anger start, stop, step och limit.

Exempel:

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 ¶

class calibre.utils.formatter_functions.BuiltinSubitems[source]¶

subitems(value, start_index, end_index) – Denna funktion bryter isär listor med taggliknande hierarkiska objekt som genrer. Den tolkar value som en kommaseparerad lista med taggliknande objekt, där varje objekt är en punktseparerad lista. Den returnerar en ny lista som skapas genom att extrahera komponenterna från start_index till end_index från varje objekt, och sedan sammanfoga resultaten igen. Dubbletter tas bort. Det första delobjektet i en punktseparerad lista har ett index på noll. Om ett index är negativt räknas det från slutet av listan. Som ett specialfall antas ett end_index på noll vara listans längd.

Exempel:

Antar en #genre-kolumn som innehåller ”A.B.C”:
- {#genre:subitems(0,1)} Returnerar ”A”
- {#genre:subitems(0,2)} Returnerar ”A.B”
- {#genre:subitems(1,0)} Returnerar ”B.C”
Antar en #genre-kolumn som innehåller ”A.B.C, D.E”:
- {#genre:subitems(0,1)} Returnerar ”A, D”
- {#genre:subitems(0,2)} Returnerar ”A.B, D.E”

sublist ¶

class calibre.utils.formatter_functions.BuiltinSublist[source]¶

sublist(value, start_index, end_index, separator) – tolka value som en lista med objekt separerade med separator, vilket returnerar en ny lista gjord av objekten från start_index till end_index. Det första objektet är nummer noll. Om ett index är negativt räknas det från slutet av listan. Som ett specialfall antas ett end_index på noll vara listans längd.

Exempel som antar att taggkolumnen (som är kommaseparerad) innehåller ”A, B, C”:

{tags:sublist(0,1,\,)} Returnerar ”A”
{tags:sublist(-1,0,\,)} Returnerar ”C”
{tags:sublist(0,-1,\,)} Returnerar ”A, B”

Listuppslag ¶

identifier_in_list ¶

class calibre.utils.formatter_functions.BuiltinIdentifierInList[source]¶

identifier_in_list(val, id_name [, found_val, not_found_val]) – treat val as a list of identifiers separated by commas. An identifier has the format id_name:value. The id_name parameter is the id_name text to search for, either id_name or id_name:regexp. The first case matches if there is any identifier matching that id_name. The second case matches if id_name matches an identifier and the regexp matches the identifier’s value. If found_val and not_found_val are provided then if there is a match then return found_val, otherwise return not_found_val. If found_val and not_found_val are not provided then if there is a match then return the identifier:value pair, otherwise the empty string ('').

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”identifier_in_list”

list_contains ¶

class calibre.utils.formatter_functions.BuiltinInList[source]¶

list_contains(value, separator, [ pattern, found_val, ]* not_found_val) – tolka value som en lista med objekt separerade med separator, och kontrollera pattern mot varje objekt i listan. Om pattern matchar ett objekt returneras found_val, annars returneras not_found_val. Paret pattern och found_value kan upprepas så många gånger som önskas, vilket gör att olika värden kan returneras beroende på objektets värde. Mönstren kontrolleras i ordning, och den första matchningen returneras.

Alias: in_list(), list_contains()

list_item ¶

class calibre.utils.formatter_functions.BuiltinListitem[source]¶

list_item(value, index, separator) – tolka value som en lista med objekt separerade med separator, vilket returnerar det ’index’te objektet. Det första objektet är nummer noll. Det sista objektet har indexet -1 som i list_item(-1,separator). Om objektet inte finns i listan returneras den tomma strängen. Avgränsaren har samma betydelse som i count-funktionen, vanligtvis komma men är et-tecken för författarliknande listor.

select ¶

class calibre.utils.formatter_functions.BuiltinSelect[source]¶

select(value, key) – tolkar value som en kommaseparerad lista med objekt där varje objekt har formen id:id_value (calibre identifier-formatet). Funktionen hittar det första paret med id lika med key och returnerar motsvarande id_value. Om inget id matchar returnerar funktionen den tomma strängen.

str_in_list ¶

class calibre.utils.formatter_functions.BuiltinStrInList[source]¶

str_in_list(value, separator, [string, found_val, ]+ not_found_val) – tolka value som en lista med objekt separerade med separator och jämför sedan string med varje värde i listan. string är inte ett reguljärt uttryck. Om string är lika med vilket objekt som helst (ignorerar gemener och versaler) returneras motsvarande found_val. Om string innehåller separators behandlas den också som en lista och varje delvärde kontrolleras. Paren string och found_value kan upprepas så många gånger som önskas, vilket gör att olika värden kan returneras beroende på strängens värde. Om ingen av strängarna matchar returneras not_found_value. Strängarna kontrolleras i ordning. Den första matchningen returneras.

Rekursion ¶

eval ¶

class calibre.utils.formatter_functions.BuiltinEval[source]¶

eval(sträng) – utvärderar strängen som ett program och skickar de lokala variablerna. Detta tillåter användning av mallprocessorn för att konstruera komplexa resultat från lokala variabler. I mallprogramläge, eftersom tecknen { och } tolkas innan mallen utvärderas, måste du använda [[ för tecknet { och ]] för tecknet }. De konverteras automatiskt. Observera också att prefix och suffix (syntaxen |prefix|suffix) inte kan användas i argumentet till den här funktionen när mallprogramläge används.

template ¶

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 anroparen och mallutvärderingen. Om du inte använder allmänt programläge, eftersom { och } tecknen är speciella, måste du använda [[ för { tecknet och ]] för tecknet }; de konverteras automatiskt. Till exempel kommer template(\'[[title_sort]]\') att utvärdera mallen {title_sort} och returnera dess värde. Observera också att prefix och suffix (syntaxen |prefix|suffix) inte kan användas i argumentet till den här funktionen när du använder mallprogramläge.

Relationellt ¶

cmp ¶

class calibre.utils.formatter_functions.BuiltinCmp[source]¶

cmp(value, y, lt, eq, gt) – jämför value och y efter att båda har konverterats till tal. Returnerar lt om value <# y, eq om value ==# y, annars gt. Denna funktion kan vanligtvis ersättas med en av de numeriska jämförelseoperatorerna (==#, <#, >#, etc.).

first_matching_cmp ¶

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[source]¶

first_matching_cmp(val, [cmp, result, ]* else_result) – jämför val < cmp i sekvens och returnerar det associerade result för den första jämförelsen som lyckas. Returnerar else_result om ingen jämförelse lyckas.

Exempel:

i = 10;
first_matching_cmp(i,5,"small",10,"middle",15,"large","giant")

returnerar "large". Samma exempel med ett första värde på 16 returnerar "giant".

strcmp ¶

class calibre.utils.formatter_functions.BuiltinStrcmp[source]¶

strcmp(x, y, lt, eq, gt) – gör en lexikal jämförelse av x och y utan att skiftläge känsligt. Returnerar lt om x < y, eq om x == y, annars gt. Denna funktion kan ofta ersättas av en av de lexikala jämförelseoperatorerna (==, >, <, etc.)

strcmpcase ¶

class calibre.utils.formatter_functions.BuiltinStrcmpcase[source]¶

strcmpcase(x, y, lt, eq, gt) – gör en skiftlägeskänslig lexikal jämförelse av x och y. Returnerar lt om x < y, eq om x == y, annars gt.

Obs: Detta är INTE standardbeteendet som används av calibre, till exempel i de lexikala jämförelseoperatorerna (==, >, <, etc.). Denna funktion kan orsaka oväntade resultat, använd helst strcmp() när det är möjligt.

Skiftlägesändringar ¶

capitalize ¶

class calibre.utils.formatter_functions.BuiltinCapitalize[source]¶

capitalize(värde) – returnerar värdet med den första bokstaven i stor bokstav och resten i liten bokstav.

lowercase ¶

class calibre.utils.formatter_functions.BuiltinLowercase[source]¶

lowercase(value) – returnerar value med gemener.

titlecase ¶

class calibre.utils.formatter_functions.BuiltinTitlecase[source]¶

titlecase(värde) – returnerar värdet i titel/gemensam version.

uppercase ¶

class calibre.utils.formatter_functions.BuiltinUppercase[source]¶

uppercase(value) – returnerar value med versaler.

Strängmanipulation ¶

character ¶

class calibre.utils.formatter_functions.BuiltinCharacter[source]¶

character(character_name) – Returnerar tecknet som namnges av character_name. Till exempel, character('newline') Returnerar ett nyradstecken ('\n'). De teckennamn som stöds är ``newline’’,``return’’, ``tab’’ och``backslash’’. Denna funktion används för att infoga dessa tecken i utmatning från mallar.

check_yes_no ¶

class calibre.utils.formatter_functions.BuiltinCheckYesNo[source]¶

check_yes_no(field_name, is_undefined, is_false, is_true) – kontrollerar om värdet på yes/no-fältet som namnges av söknamnet field_name är ett av de värden som anges av parametrarna, vilket returnerar 'Yes' om en matchning hittas, annars returneras den tomma strängen. Sätt parametern is_undefined, is_false eller is_true till 1 (talet) för att kontrollera det villkoret, annars sätt det till 0.

Exempel: check_yes_no("#bool", 1, 0, 1) returnerar 'Yes' om yes/no-fältet #bool är antingen True eller odefinierat (varken True eller False).

Mer än ett av is_undefined, is_false eller is_true kan sättas till 1.

contains ¶

class calibre.utils.formatter_functions.BuiltinContains[source]¶

contains(value, pattern, text_if_match, text_if_not_match) – kontrollerar om värdet matchas av det reguljära uttrycket pattern. Returnerar text_if_match om mönstret matchar värdet, annars returneras text_if_not_match.

field_exists ¶

class calibre.utils.formatter_functions.BuiltinFieldExists[source]¶

field_exists(lookup_name) – kontrollerar om ett fält (kolumn) med söknamnet lookup_name finns, returnerar '1' om så är fallet och den tomma strängen om inte.

ifempty ¶

class calibre.utils.formatter_functions.BuiltinIfempty[source]¶

ifempty(value, text_om_empty) – om värdet inte är tomt returnera då det value, annars returnera text_om_empty.

re ¶

class calibre.utils.formatter_functions.BuiltinRe[source]¶

re(värde, mönster, ersättning) – returnerar värdet efter att det reguljära uttrycket har tillämpats. Alla förekomster av mönster i värdet ersätts med ersättning. Mallspråket använder skiftlägeskänsliga Python-reguljära uttryck.

re_group ¶

class calibre.utils.formatter_functions.BuiltinReGroup[source]¶

re_group(value, pattern [, template_for_group]*) – return a string made by applying the regular expression pattern to value and replacing each matched instance with the value returned by the corresponding template. In Template Program Mode, like for the template and the eval functions, you use [[ for { and ]] for }.

The following example looks for a series with more than one word and uppercases the first word:

program: re_group(field('series'), "(\S* )(.*)", "{$:uppercase()}", "{$}")'}

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”`” for italics on line 1 in ”re_group”

shorten ¶

class calibre.utils.formatter_functions.BuiltinShorten[source]¶

shorten(value, left_chars, middle_text, right_chars) – Returnerar en förkortad version av value, bestående av left_chars-tecken från början av value, följt av middle_text, följt av right_chars-tecken från slutet av value. ``left_chars’’ och``right_chars’’ måste vara icke-negativa heltal.

Exempel: anta att du vill visa titeln med en längd på högst 15 tecken. En mall som gör detta är {title:shorten(9,-,5)}. För en bok med titeln Ancient English Laws in the Times of Ivanhoe` blir resultatet``Ancient E-anhoe: de första 9 tecknen i titeln, ett``-``, sedan de sista 5 tecknen. Om värdets längd är mindre än``vänster tecken’’ + ``höger tecken’’ + längden på``mittentexten’’ kommer värdet att returneras oförändrat. Till exempel skulle titeln Kupolen inte ändras.

strcat ¶

class calibre.utils.formatter_functions.BuiltinStrcat[source]¶

strcat(a[, b]*) – returnerar en sträng som bildas genom att sammanfoga alla argument. Kan ta valfritt antal argument. I de flesta fall kan du använda operatorn & istället för den här funktionen.

strcat_max ¶

class calibre.utils.formatter_functions.BuiltinStrcatMax[source]¶

strcat_max(max, string1 [, prefix2, string2]*) – Returnerar en sträng som bildas genom att sammanfoga argumenten. Det returnerade värdet initieras till string1. Strängar som bildas av prefix, sträng-par läggs till i slutet av värdet så länge som den resulterande stränglängden är mindre än max. Prefix kan vara tomma. Returnerar string1 även om string2 är längre än max. Du kan skicka med så många prefix, sträng-par som du önskar.

strlen ¶

class calibre.utils.formatter_functions.BuiltinStrlen[source]¶

strlen(value) – Returnerar längden på strängen value.

substr ¶

class calibre.utils.formatter_functions.BuiltinSubstr[source]¶

substr(value, start, end) – returns the start’th through the end’th characters of value. The first character in value is the zero’th character. If end is negative then it indicates that many characters counting from the right. If end is zero, then it indicates the last character. For example, substr('12345', 1, 0) returns '2345', and substr('12345', 1, -1) returns '234'.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”substr”

swap_around_articles ¶

class calibre.utils.formatter_functions.BuiltinSwapAroundArticles[source]¶

swap_around_articles(value, separator) – returnerar value med artiklar flyttade till slutet, separerade med semikolon. value kan vara en lista, i vilket fall varje objekt i listan bearbetas. Om value är en lista måste du ange separator. Om ingen separator anges eller om separatorn är en tom sträng behandlas value som ett enda värde, inte en lista. Articles är de som används av calibre för att generera title_sort.

swap_around_comma ¶

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[source]¶

swap_around_comma(value) – given a value of the form B, A, return A B. This is most useful for converting names in LN, FN format to FN LN. If there is no comma in the value then the function returns the value unchanged.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 1 in ”swap_around_comma”

test ¶

class calibre.utils.formatter_functions.BuiltinTest[source]¶

test(värde, text_if_not_empty, text_if_empty) – returnera text_if_not_empty om värdet inte är tomt, annars returnera text_if_empty.

transliterate ¶

class calibre.utils.formatter_functions.BuiltinTransliterate[source]¶

transliterate(value) – Returnerar en sträng i ett latinskt alfabet som bildas genom att approximera ljudet av orden i value. Till exempel, om value är Фёдор Миха́йлович Достоевский returnerar den här funktionen Fiodor Mikhailovich Dostoievskii.

URL-funktioner ¶

encode_for_url ¶

class calibre.utils.formatter_functions.BuiltinEncodeForURL[source]¶

encode_for_url(value, use_plus) – returnerar value kodat för användning i en URL enligt use_plus. Värdet URL-kodas först. Om use_plus är 0 ersätts mellanslag med '+' (plus)-tecken. Om det är 1 ersätts mellanslag med %20.

Om du inte vill att värdet ska kodas utan att mellanslag ska ersättas, använd då funktionen re(), som i re($series, ' ', '%20')

Se även funktionerna make_url(), make_url_extended() och query_string().

make_url ¶

class calibre.utils.formatter_functions.BuiltinMakeUrl[source]¶

make_url(path, [query_name, query_value]+) – den här funktionen är det enklaste sättet att konstruera en fråge-URL. Den använder en path, webbplatsen och sidan du vill fråga, och query_name, query_value-paren som frågan är byggd från. Generellt sett måste query_value vara URL-kodad. Med den här funktionen är den alltid kodad och mellanslag ersätts alltid med '+'-tecken.

Minst ett query_name, query_value-par måste anges.

Exempel: konstruera en Wikipedia-sök-URL för författaren Niccolò Machiavelli:

make_url('https://en.wikipedia.org/w/index.php', 'sökning', 'Niccolò Machiavelli')

returnerar

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Om du skriver en anpassad URL-mall för kolumnbokdetaljer, använd $item_name eller field('item_name') för att få värdet på fältet som klickades på. Exempel: om Niccolò Machiavelli klickades kan du konstruera URL:en med hjälp av:

make_url('https://en.wikipedia.org/w/index.php', 'sök', $item_name)

Se även funktionerna make_url_extended(), query_string() och encode_for_url().

make_url_extended ¶

class calibre.utils.formatter_functions.BuiltinMakeUrlExtended[source]¶

make_url_extended(...) – den här funktionen liknar make_url() men ger dig mer kontroll över URL-komponenterna. Komponenterna i en URL är

schema:://authority/path?query string.

Se Uniform Resource Locator på Wikipedia för mer information.

Funktionen har två varianter:

make_url_extended(scheme, authority, path, [query_name, query_value]+)

och

make_url_extended(scheme, authority, path, query_string)

Denna funktion returnerar en URL konstruerad från scheme, authority, path och antingen query_string eller en frågesträng konstruerad från frågeargumentparen. authority kan vara tom, vilket är fallet för calibre schema-URL:er. Du måste ange antingen en query_string eller minst ett query_name, query_value-par. Om du anger query_string och den är tom kommer den resulterande URL:en inte att ha en förfrågesträngssektion.

Exempel 1: konstruera en Wikipedia-sök-URL för författaren Niccolò Machiavelli:

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'search', 'Niccolò Machiavelli')

returnerar

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Se funktionen query_string() för ett exempel där make_url_extended() används med en query_string.

Om du skriver en anpassad URL-mall för kolumnboksdetaljer, använd $item_name eller field('item_name') för att få värdet på det fält som klickades på. Exempel: om Niccolò Machiavelli klickades på kan du konstruera URL:en med hjälp av:

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'sök', $item_name')

Se även funktionerna make_url(), query_string() och encode_for_url().

query_string ¶

class calibre.utils.formatter_functions.BuiltinQueryString[source]¶

query_string([query_name, query_value, how_to_encode]+)– returnerar en URL-förfrågesträng konstruerad från triaderna query_name, query_value, how_to_encode. En förfrågesträng är en serie poster där varje post ser ut som query_name=query_value där query_value är URL-kodat enligt instruktionerna. Frågeobjekten är separerade med '&' (et-tecken).

Om how_to_encode är 0 kodas query_value och mellanslag ersätts med '+' (plus)-tecken. Om how_to_encode är 1 kodas query_value med mellanslag ersatta av %20. Om how_to_encode är 2 returneras query_value oförändrat; Ingen kodning görs och mellanslag ersätts inte. Om du vill att query_value inte ska kodas utan att mellanslag ska ersättas, använd då funktionen re(), som i re($series, ' ', '%20')

Du använder den här funktionen om du behöver specifik kontroll över hur delarna av frågesträngen är konstruerade. Du kan sedan använda den resulterande förfrågesträngen i make_url_extended(), som i

make_url_extended(
       'https', 'your_host', 'your_path',
       query_string('encoded', 'Hendrik Bäßler', 0, 'unencoded', 'Hendrik Bäßler', 2))

vilket ger dig

https://your_host/your_path?encoded=Hendrik+B%C3%A4%C3%9Fler&unencoded=Hendrik Bäßler

Du måste ha minst en query_name, query_value, how_to_encode-triad, men du kan ha så många du vill.

Det returnerade värdet är en URL-förfrågesträng med alla angivna objekt, till exempel: name1=val1[&nameN=valN]*. Observera att avgränsaren '?' path / query string inte ingår i det returnerade resultatet.

Om du skriver en anpassad URL-mall för kolumnbokdetaljer, använd $item_name eller field('item_name') för att hämta det okodade värdet för fältet som klickades på. Du har också item_value_quoted där värdet redan är kodat med plustecken som ersätter mellanslag, och item_value_no_plus där värdet redan är kodat med %20 som ersätter mellanslag.

Se även funktionerna make_url(), make_url_extended() och encode_for_url().

to_hex ¶

class calibre.utils.formatter_functions.BuiltinToHex[source]¶

to_hex(val) – returnerar strängen val kodad i hex. Detta är användbart när man konstruerar calibre-URL:er.

urls_from_identifiers ¶

class calibre.utils.formatter_functions.BuiltinUrlsFromIdentifiers[source]¶

urls_from_identifiers(identifiers, sort_results) – given en kommaseparerad lista med identifiers, där en identifier är ett kolonsepar av värden (id_name:id_value), returnerar en kommaseparerad lista med HTML-URL:er genererade från identifierarna. Listan sorteras inte om sort_results är 0 (tecken eller siffra), annars sorteras den alfabetiskt efter identifierarens namn. URL:erna genereras på samma sätt som den inbyggda identifierarkolumnen när den visas i bokdetaljer.

Övriga ¶

arguments ¶

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 anropet. Den både deklarerar och initierar lokala variabler med de angivna namnen, id``s, vilket i praktiken gör dem till parametrar. Variablerna är positionella; de får värdet av argumentet som anges i anropet på samma position. Om motsvarande argument inte anges i anropet tilldelar ``arguments() variabeln det angivna standardvärdet. Om det inte finns något standardvärde sätts variabeln till den tomma strängen.

assign ¶

class calibre.utils.formatter_functions.BuiltinAssign[source]¶

assign(id, value) – tilldelar value till id och returnerar sedan value. id måste vara en identifierare, inte ett uttryck. I de flesta fall kan du använda operatorn = istället för den här funktionen.

globals ¶

class calibre.utils.formatter_functions.BuiltinGlobals[source]¶

globals(id[=uttryck] [, id[=uttryck]]*) – Hämtar ”globala variabler” som kan skickas till formateraren. Namnet id är namnet på den globala variabeln. Den både deklarerar och initierar lokala variabler med namnen på de globala variablerna som skickas i id-parametrarna. Om motsvarande variabel inte anges i de globala variabelerna tilldelas variabeln det angivna standardvärdet. Om det inte finns något standardvärde sätts variabeln till den tomma strängen.

is_dark_mode ¶

class calibre.utils.formatter_functions.BuiltinIsDarkMode[source]¶

is_dark_mode() – returnerar '1' om calibre körs i mörkt läge, annars '' (den tomma strängen). Denna funktion kan användas i avancerade färg- och ikonregler för att välja olika färger/ikoner beroende på läget. Exempel:

om is_dark_mode() så 'dark.png' annars 'light.png' fi

print ¶

class calibre.utils.formatter_functions.BuiltinPrint[source]¶

print(a[, b]*) – skriver argumenten till standardutdata. Om du inte startar calibre från kommandoraden (calibre-debug -g) kommer utdata att hamna i ett svart hål. Funktionen print returnerar alltid sitt första argument.

set_globals ¶

class calibre.utils.formatter_functions.BuiltinSetGlobals[source]¶

set_globals(id[=expression] [, id[=expression]]*) – Sets globalvariables that can be passed into the formatter. The globals are given the name of the id passed in. The value of the id is used unless an expression is provided.

Visar dokumentationen på engelska på grund av FFML-felet: Missing closing ”``” for CODE_TEXT on line 2 in ”set_globals”

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 items to associated hyperlink
    'link_maps',
    # Calculated page count, null values are None or 0. -1 is no countable
    # formats. -2 is error processing formats, -3 is DRMed.
    'pages',
))

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