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 + i stä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(value, y) – returnerar floor för resten av value / y. Utlöser ett undantag om antingen value 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 returneras den tomma strängen. Du kan ha så många värden du vill. I de flesta fall kan du använda operatorn && i stä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 and(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(value) – returnerar strängen '1' om värdet är tomt, annars returneras 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(value [, value]*) – returnerar strängen '1' om något värde inte är tomt, annars returneras 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 i stä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 systerfunktion 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 systerfunktion 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 i stället för att lägga in mallen i sökningen eliminerar problem som orsakas av kravet på att hantera citationstecken med escape-tecken 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 systerfunktion 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) – returnerar delar av sökvägen till ett bokformat i calibre-biblioteket, separerade med sep. Parametern sep ska vanligtvis vara ett snedstreck ('/'). En användning är att se till att sökvägar som genereras i mallarna Spara till disk och Skicka till enhet förkortas konsekvent. En annan är att se till att sökvägarna på enheten matchar sökvägarna i calibre-biblioteket.

En boksökväg består av tre segment: författaren, titeln inklusive calibres databas-ID inom parentes och formatet (författare - titel). Calibre kan förkorta vilket som helst av de tre på grund av begränsningar i filnamnslängd. Du väljer vilka segment som ska inkluderas genom att skicka 1 för det segmentet. Om du inte vill ha ett segment skickar du 0 eller den tomma strängen för det segmentet. Till exempel returnerar följande bara formatnamnet utan tillägget:

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

Eftersom det bara finns ett segment ignoreras separatorn.

Om det finns flera format (flera tillägg) kommer ett av tilläggen att väljas slumpmässigt. Om du bryr dig om vilket tillägg som används, hämta sökvägen utan tillägget och lägg sedan till önskat tillägg.

Exempel: Anta att det finns en bok i calibre-biblioteket med ett epub-format av Joe Blogs med titeln ’Hjälp’. Den skulle ha sökvägen

Joe Blogs/Hjälp - (calibre_id)/Hjälp - Joe Blogs.epub

Följande visar vad som returneras för olika parametrar:

formats_path_segments(0, 0, 1, 0, '/') returnerar Hjälp - Joe Blogs
formats_path_segments(0, 0, 1, 1, '/') returnerar Hjälp - Joe Blogs.epub
formats_path_segments(1, 0, 1, 1, '/') returnerar Joe Blogs/Hjälp - Joe Blogs.epub
formats_path_segments(1, 0, 1, 0, '/') returnerar Joe Blogs/Hjälp - Joe Blogs
formats_path_segments(0, 1, 0, 0, '/') returnerar Hjälp - (calibre_id)

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, returneras 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 tomt returneras anteckningens HTML inklusive bilder. Om plain_text är 1 (eller '1'), returneras anteckningens rena text. Om anteckningen inte finns, returneras den tomma strängen i båda fallen. Exempel:

Returnera HTML-koden för anteckningen som är kopplad till taggen Fiction:
```
program:
    get_note('tags', 'Fiction', '')
```
Returnera den rena 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) returnerar funktionen '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 funktionen en lista med värden i field_name som har en anteckning. Om inget objekt i fältet har en anteckning returnerar funktionen ''. 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 utdataformatet.Parametern user matchar som standard vilken användare som helst. Använd värdet local för att matcha läsförloppet i calibres e-bokvisare. Använd _ för att matcha läsförloppet för anonyma användare av Innehållsserverns visare. 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 kan ha följande värden:

page_count - standardvärdet, matar ut lästa sidor / totalt antal sidor. Om sidräkning inte är aktiverat matas i stället ut procent läst.
percent - matar ut procent läst
percent_number - matar ut procent läst som ett tal utan det avslutande procenttecknet, användbart för sortering.
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 formatet "EPUB"

Datumfunktioner ¶

date_arithmetic ¶

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

date_arithmetic(value, calc_spec, fmt) – beräknar 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]¶

days_between(date1, date2) – returnerar antalet dagar mellan date1 och date2. Talet är positivt om date1 är större än date2, annars negativt. Om antingen date1 eller date2 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_date 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: den {d = today(); format_date(d, 'd')} {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);
        return 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(field('series'), '([^\s])[^\s]+(\s|$)', '\1'),
        finish_formatting(field('series_index'), '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:

d : dagen som nummer utan inledande nolla (1 till 31)
dd : dagen som nummer med inledande nolla (01 till 31)
ddd : det förkortade lokaliserade veckodagsnamnet (t.ex. ”Mån” till ”Sön”)
dddd : det fullständiga lokaliserade veckodagsnamnet (t.ex. ”Måndag” till ”Söndag”)
M : månaden som nummer utan inledande nolla (1 till 12)
MM : månaden som nummer med inledande nolla (01 till 12)
MMM : det förkortade lokaliserade månadsnamnet (t.ex. ”Jan” till ”Dec”)
MMMM : det långa lokaliserade månadsnamnet (t.ex. ”Januari” till ”December”)
yy : året som ett tvåsiffrigt nummer (00 till 99)
yyyy : året som ett 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 : minuterna utan en 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-timmarsklocka i stället för en 24-timmarsklocka, med ’ap’ ersatt av den gemena lokaliserade strängen för am eller pm
AP : använd 12-timmarsklocka i stället för 24-timmarsklocka, där ’AP’ ersätts av den lokaliserade strängen med versaler för AM eller PM
aP : använd en 12-timmarsklocka i stället för en 24-timmarsklocka, där ’aP’ ersätts av den lokaliserade strängen för AM eller PM
Ap : använd en 12-timmarsklocka i stället för en 24-timmarsklocka, där ’Ap’ ersätts av den lokaliserade strängen för AM eller PM
iso : datumet med tid och tidszon. Måste vara det enda formatet som finns
to_number : konverterar datum och tid till ett flyttal (en timestamp)
from_number : konverterar ett flyttal (en timestamp) till ett ISO-formaterat datum. Om du vill ha ett annat datumformat, lägg till önskad formateringssträng efter from_number och ett kolon (:). Exempel:
```
format_date(val, 'from_number:MMM dd yyyy')
```

Du kan få oväntade resultat om datumet du formaterar innehåller lokaliserade månadsnamn, vilket kan hända om du ändrade datumformatet till att innehålla MMMM. Genom att använda format_date_field() undviks detta problem.

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', 'yyyy.MM.dd')
format_date_field('#date_read', 'MMM dd, yyyy')

format_duration ¶

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

format_duration(value, template, [largest_unit]) – 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.

format_duration(176420, '[d][h][m][s]') returnerar värdet 2d 1h 0m 20s.
format_duration(176420, '[h][m][s]') returnerar värdet 49h 0m 20s.
format_duration(176420, 'Din lästid är [d][h][m][s]') returnerar värdet Din lästid är 49h 0m 20s.
format_duration(176420, '[w][d][h][m][s]') returnerar värdet 2d 1h 0m 20s. Observera att värdet noll veckor inte returneras.

Om du vill se nollvärden för objekt som veckor i exemplet ovan, använd en versalväljare. Till exempel använder följande 'W' för att visa noll veckor:

format_duration(176420, '[W][d][h][m][s]') returnerar 0w 2d 1h 0m 20s.

Som standard är texten efter ett värde väljaren följt av ett mellanslag. Du kan ändra det till vilken text du vill. Formatet för en väljare med din text är väljaren följt av ett kolon följt av textsegment separerade med '|'-tecken. Du måste inkludera alla mellanslagstecken du vill ha i utdata.

Du kan ange från ett till tre textsegment.

Om du anger ett segment, som i [w: veckor ] används det segmentet för alla värden.
Om du anger två segment, som i [w: veckor | vecka ] används det första segmentet för 0 och mer än 1. Det andra segmentet används för 1.
Om du anger tre segment, som i [w: veckor | vecka | veckor ] används det första segmentet för 0, det andra segmentet används för 1 och det tredje segmentet används för mer än 1.

Den andra formen motsvarar den tredje formen på många språk.

Till exempel, väljaren:

[w: veckor | vecka | veckor ] producerar '0 veckor ', '1 vecka ' eller '2 veckor '.
[w: veckor | vecka ] producerar '0 veckor ', '1 vecka ' eller '2 veckor '.
[w: veckor ] producerar '0 veckor ', '1 veckor ' eller '2 veckor '.

Den valfria parametern largest_unit anger den största av veckor, dagar, timmar, minuter och sekunder som kommer att produceras av mallen. Den måste vara en av värdeväljarna. Detta kan vara användbart för att avkorta ett värde.

format_duration(176420, '[h][m][s]', 'd') returnerar värdet 1h 0m 20s i stället för 49h 0m 20s.

format_number ¶

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

format_number(value, template) – tolkar value 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 i stä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() – kontrollera om boken är marked i calibre. Om den är det returneras värdet för märket, antingen 'true' (gemener) eller en kommaseparerad lista med namngivna märken. Returnerar '' (den tomma strängen) om boken inte är markerad. Den här funktionen fungerar bara i det grafiska gränssnittet.

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() – returnerar strängen 'Yes' om ondevice är satt, annars returneras 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 i stä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 sorteringsvärde.

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) – för varje patternN, valueN-par, kontrolleras om value matchar det reguljära uttrycket patternN och returnerar i så fall det associerade valueN. Om inget patternN matchar returneras else_value. Du kan ha så många patternN, valueN-par som du önskar. Den första matchningen returneras.

switch_if ¶

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

switch_if([test_expression, value_expression,]+ else_expression) – för varje test_expression, value_expression-par, kontrolleras om test_expression är Sant (inte tomt) och returnerar om så är fallet resultatet av value_expression. Om inget test_expression är True returneras resultatet av else_expression. Du kan ha så många test_expression, value_expression-par som du vill.

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ägesokänslig 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) – returnerar yes_val om list1 och list2 innehåller samma objekt, annars 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ägesokänslig 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 separator[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ägesokänslig 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) – konstruerar 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(value, direction, separator) – returnerar value sorterat med en skiftlägesokänslig lexikal sortering. Om direction är noll (tal eller tecken) sorteras value stigande, annars fallande. Listobjekten separeras med separator, 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ägesokänslig 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]) – behandla val som en lista med identifierare separerade med kommatecken. En identifierare har formatet id_name:value. Parametern id_name är id_name-texten som ska sökas efter, antingen id_name eller id_name:regexp. Det första fallet matchar om det finns någon identifierare som matchar det id_name. Det andra fallet matchar om id_name matchar en identifierare och regexp matchar identifierarens värde. Om found_val och not_found_val anges, returneras found_val om det finns en matchning, annars returneras not_found_val. Om found_val och not_found_val inte anges, returneras paret identifier:value om det finns en matchning, annars den tomma strängen ('').

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(string) – 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 en egen kontext, vilket innebär att variabler inte delas mellan anroparen och mallutvärderingen. Om du inte använder allmänt programläge måste du, eftersom tecknen { och } är specialtecken, använda [[ för tecknet { och ]] för tecknet }; de konverteras automatiskt. Till exempel utvärderar template(\'[[title_sort]]\') mallen {title_sort} och returnerar 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 hänsyn till skiftläge. 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(value) – returnerar value 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(value) – returnerar value i titelkapitalisering.

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 returnerar character('newline') 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_if_empty) – om value inte är tomt returneras value, annars returneras text_if_empty.

re ¶

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

re(value, pattern, replacement) – returnerar value efter att det reguljära uttrycket har tillämpats. Alla förekomster av pattern i värdet ersätts med replacement. Mallspråket använder skiftlägesokänsliga reguljära uttryck i Python.

re_group ¶

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

re_group(value, pattern [, template_for_group]*) – returnerar en sträng skapad genom att tillämpa det reguljära uttrycket pattern på value och ersätta varje matchande instans med värdet som returneras av motsvarande mall. I Mallprogramläge, liksom för funktionerna template och eval, använder du [[ för { och ]] för }.

Följande exempel letar efter en serie med mer än ett ord och skriver det första ordet med versal:

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

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 left_chars + right_chars + längden på middle_text 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 & i stä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, string-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 string1 är längre än max. Du kan skicka med så många prefix, string-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) – returnerar tecknen från start till end i value. Det första tecknet i value är det nollte tecknet. Om end är negativt indikerar det att många tecken räknas från höger. Om end är noll anger det sista tecknet. Till exempel substr('12345', 1, 0) returnerar '2345' och substr('12345', 1, -1) returnerar '234'.

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) – givet ett value av formen B, A, returnerar A B. Detta är mest användbart för att konvertera namn i LN, FN-format till FN LN. Om det inte finns något kommatecken i value returnerar funktionen värdet oförändrat.

test ¶

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

test(value, text_if_not_empty, text_if_empty) – returnerar text_if_not_empty om värdet inte är tomt, annars 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', 'search', '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', 'search', $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', 'search', $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 id-namnen, 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 = i stället för den här funktionen.

globals ¶

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

globals(id[=expression] [, id[=expression]]*) – 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 variablerna 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:

if is_dark_mode() then 'dark.png' else '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]]*) – anger globalavariabler som kan skickas till formateraren. De globala variablerna får namnet på det id som skickas in. Värdet för id används om inte ett uttryck anges.

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.

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